# -*- coding: utf-8 -*-


class BindingFlags:
    """Flags to be passed to g_object_bind_property() or
g_object_bind_property_full().

This enumeration can be extended at later date."""
    DEFAULT = 0
    BIDIRECTIONAL = 1
    SYNC_CREATE = 2
    INVERT_BOOLEAN = 4


class ConnectFlags:
    """The connection flags are used to specify the behaviour of a signal's
connection."""
    AFTER = 1
    SWAPPED = 2
PARAM_MASK = r"""255"""
PARAM_STATIC_STRINGS = r"""224"""
PARAM_USER_SHIFT = r"""8"""


class ParamFlags:
    """Through the #GParamFlags flag values, certain aspects of parameters
can be configured. See also #G_PARAM_STATIC_STRINGS."""
    READABLE = 1
    WRITABLE = 2
    READWRITE = 3
    CONSTRUCT = 4
    CONSTRUCT_ONLY = 8
    LAX_VALIDATION = 16
    STATIC_NAME = 32
    PRIVATE = 32
    STATIC_NICK = 64
    STATIC_BLURB = 128
    EXPLICIT_NOTIFY = 1073741824
    DEPRECATED = 2147483648
SIGNAL_FLAGS_MASK = r"""511"""
SIGNAL_MATCH_MASK = r"""63"""


class SignalFlags:
    """The signal flags are used to specify a signal's behaviour, the overall
signal description outlines how especially the RUN flags control the
stages of a signal emission."""
    RUN_FIRST = 1
    RUN_LAST = 2
    RUN_CLEANUP = 4
    NO_RECURSE = 8
    DETAILED = 16
    ACTION = 32
    NO_HOOKS = 64
    MUST_COLLECT = 128
    DEPRECATED = 256


class SignalMatchType:
    """The match types specify what g_signal_handlers_block_matched(),
g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()
match signals by."""
    ID = 1
    DETAIL = 2
    CLOSURE = 4
    FUNC = 8
    DATA = 16
    UNBLOCKED = 32
TYPE_FLAG_RESERVED_ID_BIT = r"""1"""
TYPE_FUNDAMENTAL_MAX = r"""255"""
TYPE_FUNDAMENTAL_SHIFT = r"""2"""
TYPE_RESERVED_BSE_FIRST = r"""32"""
TYPE_RESERVED_BSE_LAST = r"""48"""
TYPE_RESERVED_GLIB_FIRST = r"""22"""
TYPE_RESERVED_GLIB_LAST = r"""31"""
TYPE_RESERVED_USER_FIRST = r"""49"""


class TypeDebugFlags:
    """These flags used to be passed to g_type_init_with_debug_flags() which
is now deprecated.

If you need to enable debugging features, use the GOBJECT_DEBUG
environment variable."""
    NONE = 0
    OBJECTS = 1
    SIGNALS = 2
    INSTANCE_COUNT = 4
    MASK = 7


class TypeFlags:
    """Bit masks used to check or determine characteristics of a type."""
    ABSTRACT = 16
    VALUE_ABSTRACT = 32


class TypeFundamentalFlags:
    """Bit masks used to check or determine specific characteristics of a
fundamental type."""
    CLASSED = 1
    INSTANTIATABLE = 2
    DERIVABLE = 4
    DEEP_DERIVABLE = 8
VALUE_COLLECT_FORMAT_MAX_LENGTH = r"""8"""
VALUE_NOCOPY_CONTENTS = r"""134217728"""

def boxed_copy(boxed_type=None, src_boxed=None):
    """    Provide a copy of a boxed structure @src_boxed which is of type @boxed_type.
    @param boxed_type: The type of @src_boxed.
    @param src_boxed: The boxed structure to be copied.
    @type boxed_type: GType
    @type src_boxed: gpointer
    @returns: The newly created copy of the boxed
    structure.
    @rtype: gpointer
    """
    return object

def boxed_free(boxed_type=None, boxed=None):
    """    Free the boxed structure @boxed which is of type @boxed_type.
    @param boxed_type: The type of @boxed.
    @param boxed: The boxed structure to be freed.
    @type boxed_type: GType
    @type boxed: gpointer
    @returns: 
    @rtype: None
    """
    return object

def boxed_type_register_static(name=None, boxed_copy=None, boxed_free=None):
    """    This function creates a new %G_TYPE_BOXED derived type id for a new
    boxed type with name @name. Boxed type handling functions have to be
    provided to copy and free opaque boxed structures of this type.
    @param name: Name of the new boxed type.
    @param boxed_copy: Boxed structure copy function.
    @param boxed_free: Boxed structure free function.
    @type name: str
    @type boxed_copy: BoxedCopyFunc
    @type boxed_free: BoxedFreeFunc
    @returns: New %G_TYPE_BOXED derived type id for @name.
    @rtype: GType
    """
    return object

def cclosure_marshal_BOOLEAN__BOXED_BOXED(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with handlers that
    take two boxed pointers as arguments and return a boolean.  If you
    have such a signal, you will probably also need to use an
    accumulator, such as g_signal_accumulator_true_handled().
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_BOOLEAN__FLAGS(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with handlers that
    take a flags type as an argument and return a boolean.  If you have
    such a signal, you will probably also need to use an accumulator,
    such as g_signal_accumulator_true_handled().
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_STRING__OBJECT_POINTER(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with handlers that
    take a #GObject and a pointer and produce a string.  It is highly
    unlikely that your signal handler fits this description.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__BOOLEAN(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    boolean argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__BOXED(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    argument which is any boxed pointer type.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__CHAR(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    character argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__DOUBLE(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with one
    double-precision floating point argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__ENUM(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    argument with an enumerated type.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__FLAGS(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    argument with a flags types.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__FLOAT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with one
    single-precision floating point argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__INT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    integer argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__LONG(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with with a single
    long integer argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__OBJECT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    #GObject argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__PARAM(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    argument of type #GParamSpec.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__POINTER(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single raw
    pointer argument type.
    
    If it is possible, it is better to use one of the more specific
    functions such as g_cclosure_marshal_VOID__OBJECT() or
    g_cclosure_marshal_VOID__OBJECT().
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__STRING(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single string
    argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__UCHAR(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    unsigned character argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__UINT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with with a single
    unsigned integer argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__UINT_POINTER(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a unsigned int
    and a pointer as arguments.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__ULONG(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    unsigned long integer argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__VARIANT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with a single
    #GVariant argument.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_VOID__VOID(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A #GClosureMarshal function for use with signals with no arguments.
    @param closure: A #GClosure.
    @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_value: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_marshal_generic(closure=None, return_gvalue=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
    """    A generic marshaller function implemented via
    [libffi](http://sourceware.org/libffi/).
    
    Normally this function is not passed explicitly to g_signal_new(),
    but used automatically by GLib when specifying a %NULL marshaller.
    @param closure: A #GClosure.
    @param return_gvalue: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
    @param n_param_values: The length of the @param_values array.
    @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
    @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
    @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
    @type closure: Closure
    @type return_gvalue: Value
    @type n_param_values: int
    @type param_values: Value
    @type invocation_hint: gpointer
    @type marshal_data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def cclosure_new(callback_func=None, user_data=None, destroy_data=None):
    """    Creates a new closure which invokes @callback_func with @user_data as
    the last parameter.
    @param callback_func: the function to invoke
    @param user_data: user data to pass to @callback_func
    @param destroy_data: destroy notify to be called when @user_data is no longer used
    @type callback_func: Callback
    @type user_data: gpointer
    @type destroy_data: ClosureNotify
    @returns: a floating reference to a new #GCClosure
    @rtype: Closure
    """
    return object

def cclosure_new_object(callback_func=None, object=None):
    """    A variant of g_cclosure_new() which uses @object as @user_data and
    calls g_object_watch_closure() on @object and the created
    closure. This function is useful when you have a callback closely
    associated with a #GObject, and want the callback to no longer run
    after the object is is freed.
    @param callback_func: the function to invoke
    @param object: a #GObject pointer to pass to @callback_func
    @type callback_func: Callback
    @type object: Object
    @returns: a new #GCClosure
    @rtype: Closure
    """
    return object

def cclosure_new_object_swap(callback_func=None, object=None):
    """    A variant of g_cclosure_new_swap() which uses @object as @user_data
    and calls g_object_watch_closure() on @object and the created
    closure. This function is useful when you have a callback closely
    associated with a #GObject, and want the callback to no longer run
    after the object is is freed.
    @param callback_func: the function to invoke
    @param object: a #GObject pointer to pass to @callback_func
    @type callback_func: Callback
    @type object: Object
    @returns: a new #GCClosure
    @rtype: Closure
    """
    return object

def cclosure_new_swap(callback_func=None, user_data=None, destroy_data=None):
    """    Creates a new closure which invokes @callback_func with @user_data as
    the first parameter.
    @param callback_func: the function to invoke
    @param user_data: user data to pass to @callback_func
    @param destroy_data: destroy notify to be called when @user_data is no longer used
    @type callback_func: Callback
    @type user_data: gpointer
    @type destroy_data: ClosureNotify
    @returns: a floating reference to a new #GCClosure
    @rtype: Closure
    """
    return object

def clear_object(object_ptr=None):
    """    Clears a reference to a #GObject.
    
    @object_ptr must not be %NULL.
    
    If the reference is %NULL then this function does nothing.
    Otherwise, the reference count of the object is decreased and the
    pointer is set to %NULL.
    
    A macro is also included that allows this function to be used without
    pointer casts.
    @param object_ptr: a pointer to a #GObject reference
    @type object_ptr: Object
    @returns: 
    @rtype: None
    """
    return object

def enum_complete_type_info(g_enum_type=None, info=None, const_values=None):
    """    This function is meant to be called from the `complete_type_info`
    function of a #GTypePlugin implementation, as in the following
    example:
    
    |[<!-- language="C" -->
    static void
    my_enum_complete_type_info (GTypePlugin     *plugin,
                                GType            g_type,
                                GTypeInfo       *info,
                                GTypeValueTable *value_table)
    {
      static const GEnumValue values[] = {
        { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
        { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
        { 0, NULL, NULL }
      };
    
      g_enum_complete_type_info (type, info, values);
    }
    ]|
    @param g_enum_type: the type identifier of the type being completed
    @param info: the #GTypeInfo struct to be filled in
    @param const_values: An array of #GEnumValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0.
    @type g_enum_type: GType
    @type info: TypeInfo
    @type const_values: EnumValue
    @returns: 
    @rtype: None
    """
    return object

def enum_get_value(enum_class=None, value=None):
    """    Returns the #GEnumValue for a value.
    @param enum_class: a #GEnumClass
    @param value: the value to look up
    @type enum_class: EnumClass
    @type value: int
    @returns: the #GEnumValue for @value, or %NULL
          if @value is not a member of the enumeration
    @rtype: EnumValue
    """
    return object

def enum_get_value_by_name(enum_class=None, name=None):
    """    Looks up a #GEnumValue by name.
    @param enum_class: a #GEnumClass
    @param name: the name to look up
    @type enum_class: EnumClass
    @type name: str
    @returns: the #GEnumValue with name @name,
          or %NULL if the enumeration doesn't have a member
          with that name
    @rtype: EnumValue
    """
    return object

def enum_get_value_by_nick(enum_class=None, nick=None):
    """    Looks up a #GEnumValue by nickname.
    @param enum_class: a #GEnumClass
    @param nick: the nickname to look up
    @type enum_class: EnumClass
    @type nick: str
    @returns: the #GEnumValue with nickname @nick,
          or %NULL if the enumeration doesn't have a member
          with that nickname
    @rtype: EnumValue
    """
    return object

def enum_register_static(name=None, const_static_values=None):
    """    Registers a new static enumeration type with the name @name.
    
    It is normally more convenient to let [glib-mkenums][glib-mkenums],
    generate a my_enum_get_type() function from a usual C enumeration
    definition  than to write one yourself using g_enum_register_static().
    @param name: A nul-terminated string used as the name of the new type.
    @param const_static_values: An array of #GEnumValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0. GObject keeps a reference to the data, so it cannot  be stack-allocated.
    @type name: str
    @type const_static_values: EnumValue
    @returns: The new type identifier.
    @rtype: GType
    """
    return object

def enum_to_string(g_enum_type=None, value=None):
    """    Pretty-prints @value in the form of the enum’s name.
    
    This is intended to be used for debugging purposes. The format of the output
    may change in the future.
    @param g_enum_type: the type identifier of a #GEnumClass type
    @param value: the value
    @type g_enum_type: GType
    @type value: int
    @returns: a newly-allocated text string
    @rtype: str
    """
    return object

def flags_complete_type_info(g_flags_type=None, info=None, const_values=None):
    """    This function is meant to be called from the complete_type_info()
    function of a #GTypePlugin implementation, see the example for
    g_enum_complete_type_info() above.
    @param g_flags_type: the type identifier of the type being completed
    @param info: the #GTypeInfo struct to be filled in
    @param const_values: An array of #GFlagsValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0.
    @type g_flags_type: GType
    @type info: TypeInfo
    @type const_values: FlagsValue
    @returns: 
    @rtype: None
    """
    return object

def flags_get_first_value(flags_class=None, value=None):
    """    Returns the first #GFlagsValue which is set in @value.
    @param flags_class: a #GFlagsClass
    @param value: the value
    @type flags_class: FlagsClass
    @type value: int
    @returns: the first #GFlagsValue which is set in
          @value, or %NULL if none is set
    @rtype: FlagsValue
    """
    return object

def flags_get_value_by_name(flags_class=None, name=None):
    """    Looks up a #GFlagsValue by name.
    @param flags_class: a #GFlagsClass
    @param name: the name to look up
    @type flags_class: FlagsClass
    @type name: str
    @returns: the #GFlagsValue with name @name,
          or %NULL if there is no flag with that name
    @rtype: FlagsValue
    """
    return object

def flags_get_value_by_nick(flags_class=None, nick=None):
    """    Looks up a #GFlagsValue by nickname.
    @param flags_class: a #GFlagsClass
    @param nick: the nickname to look up
    @type flags_class: FlagsClass
    @type nick: str
    @returns: the #GFlagsValue with nickname @nick,
          or %NULL if there is no flag with that nickname
    @rtype: FlagsValue
    """
    return object

def flags_register_static(name=None, const_static_values=None):
    """    Registers a new static flags type with the name @name.
    
    It is normally more convenient to let [glib-mkenums][glib-mkenums]
    generate a my_flags_get_type() function from a usual C enumeration
    definition than to write one yourself using g_flags_register_static().
    @param name: A nul-terminated string used as the name of the new type.
    @param const_static_values: An array of #GFlagsValue structs for the possible  flags values. The array is terminated by a struct with all members being 0.  GObject keeps a reference to the data, so it cannot be stack-allocated.
    @type name: str
    @type const_static_values: FlagsValue
    @returns: The new type identifier.
    @rtype: GType
    """
    return object

def flags_to_string(flags_type=None, value=None):
    """    Pretty-prints @value in the form of the flag names separated by ` | ` and
    sorted. Any extra bits will be shown at the end as a hexadecimal number.
    
    This is intended to be used for debugging purposes. The format of the output
    may change in the future.
    @param flags_type: the type identifier of a #GFlagsClass type
    @param value: the value
    @type flags_type: GType
    @type value: int
    @returns: a newly-allocated text string
    @rtype: str
    """
    return object

def gtype_get_type():
    """    
    @returns: 
    @rtype: GType
    """
    return object

def param_spec_boolean(name=None, nick=None, blurb=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
    property. In many cases, it may be more appropriate to use an enum with
    g_param_spec_enum(), both to improve code clarity by using explicitly named
    values, and to allow for more values to be added in future without breaking
    API.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type default_value: bool
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_boxed(name=None, nick=None, blurb=None, boxed_type=None, flags=None):
    """    Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
    derived property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param boxed_type: %G_TYPE_BOXED derived type of this property
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type boxed_type: GType
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_char(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: gint8
    @type maximum: gint8
    @type default_value: gint8
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_double(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
    property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: float
    @type maximum: float
    @type default_value: float
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_enum(name=None, nick=None, blurb=None, enum_type=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
    property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param enum_type: a #GType derived from %G_TYPE_ENUM
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type enum_type: GType
    @type default_value: int
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_flags(name=None, nick=None, blurb=None, flags_type=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
    property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param flags_type: a #GType derived from %G_TYPE_FLAGS
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type flags_type: GType
    @type default_value: int
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_float(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: float
    @type maximum: float
    @type default_value: float
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_gtype(name=None, nick=None, blurb=None, is_a_type=None, flags=None):
    """    Creates a new #GParamSpecGType instance specifying a
    %G_TYPE_GTYPE property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param is_a_type: a #GType whose subtypes are allowed as values  of the property (use %G_TYPE_NONE for any type)
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type is_a_type: GType
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_int(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: int
    @type maximum: int
    @type default_value: int
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_int64(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: int
    @type maximum: int
    @type default_value: int
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_long(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: long
    @type maximum: long
    @type default_value: long
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_object(name=None, nick=None, blurb=None, object_type=None, flags=None):
    """    Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
    derived property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param object_type: %G_TYPE_OBJECT derived type of this property
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type object_type: GType
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_override(name=None, overridden=None):
    """    Creates a new property of type #GParamSpecOverride. This is used
    to direct operations to another paramspec, and will not be directly
    useful unless you are implementing a new base type similar to GObject.
    @param name: the name of the property.
    @param overridden: The property that is being overridden
    @type name: str
    @type overridden: ParamSpec
    @returns: the newly created #GParamSpec
    @rtype: ParamSpec
    """
    return object

def param_spec_param(name=None, nick=None, blurb=None, param_type=None, flags=None):
    """    Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
    property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param param_type: a #GType derived from %G_TYPE_PARAM
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type param_type: GType
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_pointer(name=None, nick=None, blurb=None, flags=None):
    """    Creates a new #GParamSpecPointer instance specifying a pointer property.
    Where possible, it is better to use g_param_spec_object() or
    g_param_spec_boxed() to expose memory management information.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_pool_new(type_prefixing=None):
    """    Creates a new #GParamSpecPool.
    
    If @type_prefixing is %TRUE, lookups in the newly created pool will
    allow to specify the owner as a colon-separated prefix of the
    property name, like "GtkContainer:border-width". This feature is
    deprecated, so you should always set @type_prefixing to %FALSE.
    @param type_prefixing: Whether the pool will support type-prefixed property names.
    @type type_prefixing: bool
    @returns: a newly allocated #GParamSpecPool.
    @rtype: ParamSpecPool
    """
    return object

def param_spec_string(name=None, nick=None, blurb=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecString instance.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type default_value: str
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_uchar(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: guint8
    @type maximum: guint8
    @type default_value: guint8
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_uint(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: int
    @type maximum: int
    @type default_value: int
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_uint64(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
    property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: int
    @type maximum: int
    @type default_value: int
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_ulong(name=None, nick=None, blurb=None, minimum=None, maximum=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
    property.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param minimum: minimum value for the property specified
    @param maximum: maximum value for the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type minimum: long
    @type maximum: long
    @type default_value: long
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_unichar(name=None, nick=None, blurb=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
    property. #GValue structures for this property can be accessed with
    g_value_set_uint() and g_value_get_uint().
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param default_value: default value for the property specified
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type default_value: gunichar
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_value_array(name=None, nick=None, blurb=None, element_spec=None, flags=None):
    """    Creates a new #GParamSpecValueArray instance specifying a
    %G_TYPE_VALUE_ARRAY property. %G_TYPE_VALUE_ARRAY is a
    %G_TYPE_BOXED type, as such, #GValue structures for this property
    can be accessed with g_value_set_boxed() and g_value_get_boxed().
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param element_spec: a #GParamSpec describing the elements contained in  arrays of this property, may be %NULL
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type element_spec: ParamSpec
    @type flags: ParamFlags
    @returns: a newly created parameter specification
    @rtype: ParamSpec
    """
    return object

def param_spec_variant(name=None, nick=None, blurb=None, type=None, default_value=None, flags=None):
    """    Creates a new #GParamSpecVariant instance specifying a #GVariant
    property.
    
    If @default_value is floating, it is consumed.
    
    See g_param_spec_internal() for details on property names.
    @param name: canonical name of the property specified
    @param nick: nick name for the property specified
    @param blurb: description of the property specified
    @param type: a #GVariantType
    @param default_value: a #GVariant of type @type to                 use as the default value, or %NULL
    @param flags: flags for the property specified
    @type name: str
    @type nick: str
    @type blurb: str
    @type type: GLib.VariantType
    @type default_value: GLib.Variant
    @type flags: ParamFlags
    @returns: the newly created #GParamSpec
    @rtype: ParamSpec
    """
    return object

def param_type_register_static(name=None, pspec_info=None):
    """    Registers @name as the name of a new static type derived from
    #G_TYPE_PARAM. The type system uses the information contained in
    the #GParamSpecTypeInfo structure pointed to by @info to manage the
    #GParamSpec type and its instances.
    @param name: 0-terminated string used as the name of the new #GParamSpec type.
    @param pspec_info: The #GParamSpecTypeInfo for this #GParamSpec type.
    @type name: str
    @type pspec_info: ParamSpecTypeInfo
    @returns: The new type identifier.
    @rtype: GType
    """
    return object

def param_value_convert(pspec=None, src_value=None, dest_value=None, strict_validation=None):
    """    Transforms @src_value into @dest_value if possible, and then
    validates @dest_value, in order for it to conform to @pspec.  If
    @strict_validation is %TRUE this function will only succeed if the
    transformed @dest_value complied to @pspec without modifications.
    
    See also g_value_type_transformable(), g_value_transform() and
    g_param_value_validate().
    @param pspec: a valid #GParamSpec
    @param src_value: souce #GValue
    @param dest_value: destination #GValue of correct type for @pspec
    @param strict_validation: %TRUE requires @dest_value to conform to @pspec without modifications
    @type pspec: ParamSpec
    @type src_value: Value
    @type dest_value: Value
    @type strict_validation: bool
    @returns: %TRUE if transformation and validation were successful,  %FALSE otherwise and @dest_value is left untouched.
    @rtype: bool
    """
    return object

def param_value_defaults(pspec=None, value=None):
    """    Checks whether @value contains the default value as specified in @pspec.
    @param pspec: a valid #GParamSpec
    @param value: a #GValue of correct type for @pspec
    @type pspec: ParamSpec
    @type value: Value
    @returns: whether @value contains the canonical default for this @pspec
    @rtype: bool
    """
    return object

def param_value_set_default(pspec=None, value=None):
    """    Sets @value to its default value as specified in @pspec.
    @param pspec: a valid #GParamSpec
    @param value: a #GValue of correct type for @pspec
    @type pspec: ParamSpec
    @type value: Value
    @returns: 
    @rtype: None
    """
    return object

def param_value_validate(pspec=None, value=None):
    """    Ensures that the contents of @value comply with the specifications
    set out by @pspec. For example, a #GParamSpecInt might require
    that integers stored in @value may not be smaller than -42 and not be
    greater than +42. If @value contains an integer outside of this range,
    it is modified accordingly, so the resulting value will fit into the
    range -42 .. +42.
    @param pspec: a valid #GParamSpec
    @param value: a #GValue of correct type for @pspec
    @type pspec: ParamSpec
    @type value: Value
    @returns: whether modifying @value was necessary to ensure validity
    @rtype: bool
    """
    return object

def param_values_cmp(pspec=None, value1=None, value2=None):
    """    Compares @value1 with @value2 according to @pspec, and return -1, 0 or +1,
    if @value1 is found to be less than, equal to or greater than @value2,
    respectively.
    @param pspec: a valid #GParamSpec
    @param value1: a #GValue of correct type for @pspec
    @param value2: a #GValue of correct type for @pspec
    @type pspec: ParamSpec
    @type value1: Value
    @type value2: Value
    @returns: -1, 0 or +1, for a less than, equal to or greater than result
    @rtype: int
    """
    return object

def pointer_type_register_static(name=None):
    """    Creates a new %G_TYPE_POINTER derived type id for a new
    pointer type with name @name.
    @param name: the name of the new pointer type.
    @type name: str
    @returns: a new %G_TYPE_POINTER derived type id for @name.
    @rtype: GType
    """
    return object

def signal_accumulator_first_wins(ihint=None, return_accu=None, handler_return=None, dummy=None):
    """    A predefined #GSignalAccumulator for signals intended to be used as a
    hook for application code to provide a particular value.  Usually
    only one such value is desired and multiple handlers for the same
    signal don't make much sense (except for the case of the default
    handler defined in the class structure, in which case you will
    usually want the signal connection to override the class handler).
    
    This accumulator will use the return value from the first signal
    handler that is run as the return value for the signal and not run
    any further handlers (ie: the first handler "wins").
    @param ihint: standard #GSignalAccumulator parameter
    @param return_accu: standard #GSignalAccumulator parameter
    @param handler_return: standard #GSignalAccumulator parameter
    @param dummy: standard #GSignalAccumulator parameter
    @type ihint: SignalInvocationHint
    @type return_accu: Value
    @type handler_return: Value
    @type dummy: gpointer
    @returns: standard #GSignalAccumulator result
    @rtype: bool
    """
    return object

def signal_accumulator_true_handled(ihint=None, return_accu=None, handler_return=None, dummy=None):
    """    A predefined #GSignalAccumulator for signals that return a
    boolean values. The behavior that this accumulator gives is
    that a return of %TRUE stops the signal emission: no further
    callbacks will be invoked, while a return of %FALSE allows
    the emission to continue. The idea here is that a %TRUE return
    indicates that the callback handled the signal, and no further
    handling is needed.
    @param ihint: standard #GSignalAccumulator parameter
    @param return_accu: standard #GSignalAccumulator parameter
    @param handler_return: standard #GSignalAccumulator parameter
    @param dummy: standard #GSignalAccumulator parameter
    @type ihint: SignalInvocationHint
    @type return_accu: Value
    @type handler_return: Value
    @type dummy: gpointer
    @returns: standard #GSignalAccumulator result
    @rtype: bool
    """
    return object

def signal_add_emission_hook(signal_id=None, detail=None, hook_func=None, hook_data=None, data_destroy=None):
    """    Adds an emission hook for a signal, which will get called for any emission
    of that signal, independent of the instance. This is possible only
    for signals which don't have #G_SIGNAL_NO_HOOKS flag set.
    @param signal_id: the signal identifier, as returned by g_signal_lookup().
    @param detail: the detail on which to call the hook.
    @param hook_func: a #GSignalEmissionHook function.
    @param hook_data: user data for @hook_func.
    @param data_destroy: a #GDestroyNotify for @hook_data.
    @type signal_id: int
    @type detail: GLib.Quark
    @type hook_func: SignalEmissionHook
    @type hook_data: gpointer
    @type data_destroy: GLib.DestroyNotify
    @returns: the hook id, for later use with g_signal_remove_emission_hook().
    @rtype: long
    """
    return object

def signal_chain_from_overridden(instance_and_params=None, return_value=None):
    """    Calls the original class closure of a signal. This function should only
    be called from an overridden class closure; see
    g_signal_override_class_closure() and
    g_signal_override_class_handler().
    @param instance_and_params: the argument list of the signal emission.  The first element in the array is a #GValue for the instance the signal  is being emitted on. The rest are any arguments to be passed to the signal.
    @param return_value: Location for the return value.
    @type return_value: Value
    @returns: 
    @rtype: None
    """
    return object

def signal_chain_from_overridden_handler(instance=None, *args):
    """    Calls the original class closure of a signal. This function should
    only be called from an overridden class closure; see
    g_signal_override_class_closure() and
    g_signal_override_class_handler().
    @param instance: the instance the signal is being    emitted on.
    @param *args: parameters to be passed to the parent class closure, followed by a  location for the return value. If the return type of the signal  is #G_TYPE_NONE, the return value location can be omitted.
    @type instance: TypeInstance
    @returns: 
    @rtype: None
    """
    return object

def signal_connect_closure(instance=None, detailed_signal=None, closure=None, after=None):
    """    Connects a closure to a signal for a particular object.
    @param instance: the instance to connect to.
    @param detailed_signal: a string of the form "signal-name::detail".
    @param closure: the closure to connect.
    @param after: whether the handler should be called before or after the  default handler of the signal.
    @type instance: Object
    @type detailed_signal: str
    @type closure: Closure
    @type after: bool
    @returns: the handler ID (always greater than 0 for successful connections)
    @rtype: long
    """
    return object

def signal_connect_closure_by_id(instance=None, signal_id=None, detail=None, closure=None, after=None):
    """    Connects a closure to a signal for a particular object.
    @param instance: the instance to connect to.
    @param signal_id: the id of the signal.
    @param detail: the detail.
    @param closure: the closure to connect.
    @param after: whether the handler should be called before or after the  default handler of the signal.
    @type instance: Object
    @type signal_id: int
    @type detail: GLib.Quark
    @type closure: Closure
    @type after: bool
    @returns: the handler ID (always greater than 0 for successful connections)
    @rtype: long
    """
    return object

def signal_connect_data(instance=None, detailed_signal=None, c_handler=None, data=None, destroy_data=None, connect_flags=None):
    """    Connects a #GCallback function to a signal for a particular object. Similar
    to g_signal_connect(), but allows to provide a #GClosureNotify for the data
    which will be called when the signal handler is disconnected and no longer
    used. Specify @connect_flags if you need `..._after()` or
    `..._swapped()` variants of this function.
    @param instance: the instance to connect to.
    @param detailed_signal: a string of the form "signal-name::detail".
    @param c_handler: the #GCallback to connect.
    @param data: data to pass to @c_handler calls.
    @param destroy_data: a #GClosureNotify for @data.
    @param connect_flags: a combination of #GConnectFlags.
    @type instance: Object
    @type detailed_signal: str
    @type c_handler: Callback
    @type data: gpointer
    @type destroy_data: ClosureNotify
    @type connect_flags: ConnectFlags
    @returns: the handler ID (always greater than 0 for successful connections)
    @rtype: long
    """
    return object

def signal_connect_object(instance=None, detailed_signal=None, c_handler=None, gobject=None, connect_flags=None):
    """    This is similar to g_signal_connect_data(), but uses a closure which
    ensures that the @gobject stays alive during the call to @c_handler
    by temporarily adding a reference count to @gobject.
    
    When the @gobject is destroyed the signal handler will be automatically
    disconnected.  Note that this is not currently threadsafe (ie:
    emitting a signal while @gobject is being destroyed in another thread
    is not safe).
    @param instance: the instance to connect to.
    @param detailed_signal: a string of the form "signal-name::detail".
    @param c_handler: the #GCallback to connect.
    @param gobject: the object to pass as data    to @c_handler.
    @param connect_flags: a combination of #GConnectFlags.
    @type instance: TypeInstance
    @type detailed_signal: str
    @type c_handler: Callback
    @type gobject: Object
    @type connect_flags: ConnectFlags
    @returns: the handler id.
    @rtype: long
    """
    return object

def signal_emit(instance=None, signal_id=None, detail=None, *args):
    """    Emits a signal.
    
    Note that g_signal_emit() resets the return value to the default
    if no handlers are connected, in contrast to g_signal_emitv().
    @param instance: the instance the signal is being emitted on.
    @param signal_id: the signal id
    @param detail: the detail
    @param *args: parameters to be passed to the signal, followed by a  location for the return value. If the return type of the signal  is #G_TYPE_NONE, the return value location can be omitted.
    @type instance: Object
    @type signal_id: int
    @type detail: GLib.Quark
    @returns: 
    @rtype: None
    """
    return object

def signal_emit_by_name(instance=None, detailed_signal=None, *args):
    """    Emits a signal.
    
    Note that g_signal_emit_by_name() resets the return value to the default
    if no handlers are connected, in contrast to g_signal_emitv().
    @param instance: the instance the signal is being emitted on.
    @param detailed_signal: a string of the form "signal-name::detail".
    @param *args: parameters to be passed to the signal, followed by a  location for the return value. If the return type of the signal  is #G_TYPE_NONE, the return value location can be omitted.
    @type instance: Object
    @type detailed_signal: str
    @returns: 
    @rtype: None
    """
    return object

def signal_emit_valist(instance=None, signal_id=None, detail=None, var_args=None):
    """    Emits a signal.
    
    Note that g_signal_emit_valist() resets the return value to the default
    if no handlers are connected, in contrast to g_signal_emitv().
    @param instance: the instance the signal is being    emitted on.
    @param signal_id: the signal id
    @param detail: the detail
    @param var_args: a list of parameters to be passed to the signal, followed by a  location for the return value. If the return type of the signal  is #G_TYPE_NONE, the return value location can be omitted.
    @type instance: TypeInstance
    @type signal_id: int
    @type detail: GLib.Quark
    @type var_args: va_list
    @returns: 
    @rtype: None
    """
    return object

def signal_emitv(instance_and_params=None, signal_id=None, detail=None, return_value=None):
    """    Emits a signal.
    
    Note that g_signal_emitv() doesn't change @return_value if no handlers are
    connected, in contrast to g_signal_emit() and g_signal_emit_valist().
    @param instance_and_params: argument list for the signal emission.  The first element in the array is a #GValue for the instance the signal  is being emitted on. The rest are any arguments to be passed to the signal.
    @param signal_id: the signal id
    @param detail: the detail
    @param return_value: Location to store the return value of the signal emission. This must be provided if the specified signal returns a value, but may be ignored otherwise.
    @type signal_id: int
    @type detail: GLib.Quark
    @type return_value: Value
    @returns: 
    @rtype: None
    """
    return object

def signal_get_invocation_hint(instance=None):
    """    Returns the invocation hint of the innermost signal emission of instance.
    @param instance: the instance to query
    @type instance: Object
    @returns: the invocation hint of the innermost signal  emission.
    @rtype: SignalInvocationHint
    """
    return object

def signal_handler_block(instance=None, handler_id=None):
    """    Blocks a handler of an instance so it will not be called during any
    signal emissions unless it is unblocked again. Thus "blocking" a
    signal handler means to temporarily deactive it, a signal handler
    has to be unblocked exactly the same amount of times it has been
    blocked before to become active again.
    
    The @handler_id has to be a valid signal handler id, connected to a
    signal of @instance.
    @param instance: The instance to block the signal handler of.
    @param handler_id: Handler id of the handler to be blocked.
    @type instance: Object
    @type handler_id: long
    @returns: 
    @rtype: None
    """
    return object

def signal_handler_disconnect(instance=None, handler_id=None):
    """    Disconnects a handler from an instance so it will not be called during
    any future or currently ongoing emissions of the signal it has been
    connected to. The @handler_id becomes invalid and may be reused.
    
    The @handler_id has to be a valid signal handler id, connected to a
    signal of @instance.
    @param instance: The instance to remove the signal handler from.
    @param handler_id: Handler id of the handler to be disconnected.
    @type instance: Object
    @type handler_id: long
    @returns: 
    @rtype: None
    """
    return object

def signal_handler_find(instance=None, mask=None, signal_id=None, detail=None, closure=None, func=None, data=None):
    """    Finds the first signal handler that matches certain selection criteria.
    The criteria mask is passed as an OR-ed combination of #GSignalMatchType
    flags, and the criteria values are passed as arguments.
    The match @mask has to be non-0 for successful matches.
    If no handler was found, 0 is returned.
    @param instance: The instance owning the signal handler to be found.
    @param mask: Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handler has to match.
    @param signal_id: Signal the handler has to be connected to.
    @param detail: Signal detail the handler has to be connected to.
    @param closure: The closure the handler will invoke.
    @param func: The C closure callback of the handler (useless for non-C closures).
    @param data: The closure data of the handler's closure.
    @type instance: Object
    @type mask: SignalMatchType
    @type signal_id: int
    @type detail: GLib.Quark
    @type closure: Closure
    @type func: gpointer
    @type data: gpointer
    @returns: A valid non-0 signal handler id for a successful match.
    @rtype: long
    """
    return object

def signal_handler_is_connected(instance=None, handler_id=None):
    """    Returns whether @handler_id is the ID of a handler connected to @instance.
    @param instance: The instance where a signal handler is sought.
    @param handler_id: the handler ID.
    @type instance: Object
    @type handler_id: long
    @returns: whether @handler_id identifies a handler connected to @instance.
    @rtype: bool
    """
    return object

def signal_handler_unblock(instance=None, handler_id=None):
    """    Undoes the effect of a previous g_signal_handler_block() call.  A
    blocked handler is skipped during signal emissions and will not be
    invoked, unblocking it (for exactly the amount of times it has been
    blocked before) reverts its "blocked" state, so the handler will be
    recognized by the signal system and is called upon future or
    currently ongoing signal emissions (since the order in which
    handlers are called during signal emissions is deterministic,
    whether the unblocked handler in question is called as part of a
    currently ongoing emission depends on how far that emission has
    proceeded yet).
    
    The @handler_id has to be a valid id of a signal handler that is
    connected to a signal of @instance and is currently blocked.
    @param instance: The instance to unblock the signal handler of.
    @param handler_id: Handler id of the handler to be unblocked.
    @type instance: Object
    @type handler_id: long
    @returns: 
    @rtype: None
    """
    return object

def signal_handlers_block_matched(instance=None, mask=None, signal_id=None, detail=None, closure=None, func=None, data=None):
    """    Blocks all handlers on an instance that match a certain selection criteria.
    The criteria mask is passed as an OR-ed combination of #GSignalMatchType
    flags, and the criteria values are passed as arguments.
    Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
    or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
    If no handlers were found, 0 is returned, the number of blocked handlers
    otherwise.
    @param instance: The instance to block handlers from.
    @param mask: Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handlers have to match.
    @param signal_id: Signal the handlers have to be connected to.
    @param detail: Signal detail the handlers have to be connected to.
    @param closure: The closure the handlers will invoke.
    @param func: The C closure callback of the handlers (useless for non-C closures).
    @param data: The closure data of the handlers' closures.
    @type instance: Object
    @type mask: SignalMatchType
    @type signal_id: int
    @type detail: GLib.Quark
    @type closure: Closure
    @type func: gpointer
    @type data: gpointer
    @returns: The number of handlers that matched.
    @rtype: int
    """
    return object

def signal_handlers_destroy(instance=None):
    """    Destroy all signal handlers of a type instance. This function is
    an implementation detail of the #GObject dispose implementation,
    and should not be used outside of the type system.
    @param instance: The instance whose signal handlers are destroyed
    @type instance: Object
    @returns: 
    @rtype: None
    """
    return object

def signal_handlers_disconnect_matched(instance=None, mask=None, signal_id=None, detail=None, closure=None, func=None, data=None):
    """    Disconnects all handlers on an instance that match a certain
    selection criteria. The criteria mask is passed as an OR-ed
    combination of #GSignalMatchType flags, and the criteria values are
    passed as arguments.  Passing at least one of the
    %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC or
    %G_SIGNAL_MATCH_DATA match flags is required for successful
    matches.  If no handlers were found, 0 is returned, the number of
    disconnected handlers otherwise.
    @param instance: The instance to remove handlers from.
    @param mask: Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handlers have to match.
    @param signal_id: Signal the handlers have to be connected to.
    @param detail: Signal detail the handlers have to be connected to.
    @param closure: The closure the handlers will invoke.
    @param func: The C closure callback of the handlers (useless for non-C closures).
    @param data: The closure data of the handlers' closures.
    @type instance: Object
    @type mask: SignalMatchType
    @type signal_id: int
    @type detail: GLib.Quark
    @type closure: Closure
    @type func: gpointer
    @type data: gpointer
    @returns: The number of handlers that matched.
    @rtype: int
    """
    return object

def signal_handlers_unblock_matched(instance=None, mask=None, signal_id=None, detail=None, closure=None, func=None, data=None):
    """    Unblocks all handlers on an instance that match a certain selection
    criteria. The criteria mask is passed as an OR-ed combination of
    #GSignalMatchType flags, and the criteria values are passed as arguments.
    Passing at least one of the %G_SIGNAL_MATCH_CLOSURE, %G_SIGNAL_MATCH_FUNC
    or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
    If no handlers were found, 0 is returned, the number of unblocked handlers
    otherwise. The match criteria should not apply to any handlers that are
    not currently blocked.
    @param instance: The instance to unblock handlers from.
    @param mask: Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handlers have to match.
    @param signal_id: Signal the handlers have to be connected to.
    @param detail: Signal detail the handlers have to be connected to.
    @param closure: The closure the handlers will invoke.
    @param func: The C closure callback of the handlers (useless for non-C closures).
    @param data: The closure data of the handlers' closures.
    @type instance: Object
    @type mask: SignalMatchType
    @type signal_id: int
    @type detail: GLib.Quark
    @type closure: Closure
    @type func: gpointer
    @type data: gpointer
    @returns: The number of handlers that matched.
    @rtype: int
    """
    return object

def signal_has_handler_pending(instance=None, signal_id=None, detail=None, may_be_blocked=None):
    """    Returns whether there are any handlers connected to @instance for the
    given signal id and detail.
    
    If @detail is 0 then it will only match handlers that were connected
    without detail.  If @detail is non-zero then it will match handlers
    connected both without detail and with the given detail.  This is
    consistent with how a signal emitted with @detail would be delivered
    to those handlers.
    
    Since 2.46 this also checks for a non-default class closure being
    installed, as this is basically always what you want.
    
    One example of when you might use this is when the arguments to the
    signal are difficult to compute. A class implementor may opt to not
    emit the signal if no one is attached anyway, thus saving the cost
    of building the arguments.
    @param instance: the object whose signal handlers are sought.
    @param signal_id: the signal id.
    @param detail: the detail.
    @param may_be_blocked: whether blocked handlers should count as match.
    @type instance: Object
    @type signal_id: int
    @type detail: GLib.Quark
    @type may_be_blocked: bool
    @returns: %TRUE if a handler is connected to the signal, %FALSE
          otherwise.
    @rtype: bool
    """
    return object

def signal_list_ids(itype=None, n_ids=None):
    """    Lists the signals by id that a certain instance or interface type
    created. Further information about the signals can be acquired through
    g_signal_query().
    @param itype: Instance or interface type.
    @param n_ids: Location to store the number of signal ids for @itype.
    @type itype: GType
    @type n_ids: int
    @rtype: None
    """
    return object

def signal_lookup(name=None, itype=None):
    """    Given the name of the signal and the type of object it connects to, gets
    the signal's identifying integer. Emitting the signal by number is
    somewhat faster than using the name each time.
    
    Also tries the ancestors of the given type.
    
    See g_signal_new() for details on allowed signal names.
    @param name: the signal's name.
    @param itype: the type that the signal operates on.
    @type name: str
    @type itype: GType
    @returns: the signal's identifying number, or 0 if no signal was found.
    @rtype: int
    """
    return object

def signal_name(signal_id=None):
    """    Given the signal's identifier, finds its name.
    
    Two different signals may have the same name, if they have differing types.
    @param signal_id: the signal's identifying number.
    @type signal_id: int
    @returns: the signal name, or %NULL if the signal number was invalid.
    @rtype: str
    """
    return object

def signal_new(signal_name=None, itype=None, signal_flags=None, class_offset=None, accumulator=None, accu_data=None, c_marshaller=None, return_type=None, n_params=None, *args):
    """    Creates a new signal. (This is usually done in the class initializer.)
    
    A signal name consists of segments consisting of ASCII letters and
    digits, separated by either the '-' or '_' character. The first
    character of a signal name must be a letter. Names which violate these
    rules lead to undefined behaviour of the GSignal system.
    
    When registering a signal and looking up a signal, either separator can
    be used, but they cannot be mixed.
    
    If 0 is used for @class_offset subclasses cannot override the class handler
    in their class_init method by doing super_class->signal_handler = my_signal_handler.
    Instead they will have to use g_signal_override_class_handler().
    
    If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
    the marshaller for this signal.
    @param signal_name: the name for the signal
    @param itype: the type this signal pertains to. It will also pertain to  types which are derived from this type.
    @param signal_flags: a combination of #GSignalFlags specifying detail of when  the default handler is to be invoked. You should at least specify  %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST.
    @param class_offset: The offset of the function pointer in the class structure  for this type. Used to invoke a class method generically. Pass 0 to  not associate a class method slot with this signal.
    @param accumulator: the accumulator for this signal; may be %NULL.
    @param accu_data: user data for the @accumulator.
    @param c_marshaller: the function to translate arrays of parameter  values to signal emissions into C language callback invocations or %NULL.
    @param return_type: the type of return value, or #G_TYPE_NONE for a signal  without a return value.
    @param n_params: the number of parameter types to follow.
    @param *args: a list of types, one for each parameter.
    @type signal_name: str
    @type itype: GType
    @type signal_flags: SignalFlags
    @type class_offset: int
    @type accumulator: SignalAccumulator
    @type accu_data: gpointer
    @type c_marshaller: SignalCMarshaller
    @type return_type: GType
    @type n_params: int
    @returns: the signal id
    @rtype: int
    """
    return object

def signal_new_class_handler(signal_name=None, itype=None, signal_flags=None, class_handler=None, accumulator=None, accu_data=None, c_marshaller=None, return_type=None, n_params=None, *args):
    """    Creates a new signal. (This is usually done in the class initializer.)
    
    This is a variant of g_signal_new() that takes a C callback instead
    off a class offset for the signal's class handler. This function
    doesn't need a function pointer exposed in the class structure of
    an object definition, instead the function pointer is passed
    directly and can be overriden by derived classes with
    g_signal_override_class_closure() or
    g_signal_override_class_handler()and chained to with
    g_signal_chain_from_overridden() or
    g_signal_chain_from_overridden_handler().
    
    See g_signal_new() for information about signal names.
    
    If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
    the marshaller for this signal.
    @param signal_name: the name for the signal
    @param itype: the type this signal pertains to. It will also pertain to  types which are derived from this type.
    @param signal_flags: a combination of #GSignalFlags specifying detail of when  the default handler is to be invoked. You should at least specify  %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST.
    @param class_handler: a #GCallback which acts as class implementation of  this signal. Used to invoke a class method generically. Pass %NULL to  not associate a class method with this signal.
    @param accumulator: the accumulator for this signal; may be %NULL.
    @param accu_data: user data for the @accumulator.
    @param c_marshaller: the function to translate arrays of parameter  values to signal emissions into C language callback invocations or %NULL.
    @param return_type: the type of return value, or #G_TYPE_NONE for a signal  without a return value.
    @param n_params: the number of parameter types to follow.
    @param *args: a list of types, one for each parameter.
    @type signal_name: str
    @type itype: GType
    @type signal_flags: SignalFlags
    @type class_handler: Callback
    @type accumulator: SignalAccumulator
    @type accu_data: gpointer
    @type c_marshaller: SignalCMarshaller
    @type return_type: GType
    @type n_params: int
    @returns: the signal id
    @rtype: int
    """
    return object

def signal_new_valist(signal_name=None, itype=None, signal_flags=None, class_closure=None, accumulator=None, accu_data=None, c_marshaller=None, return_type=None, n_params=None, args=None):
    """    Creates a new signal. (This is usually done in the class initializer.)
    
    See g_signal_new() for details on allowed signal names.
    
    If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
    the marshaller for this signal.
    @param signal_name: the name for the signal
    @param itype: the type this signal pertains to. It will also pertain to  types which are derived from this type.
    @param signal_flags: a combination of #GSignalFlags specifying detail of when  the default handler is to be invoked. You should at least specify  %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST.
    @param class_closure: The closure to invoke on signal emission; may be %NULL.
    @param accumulator: the accumulator for this signal; may be %NULL.
    @param accu_data: user data for the @accumulator.
    @param c_marshaller: the function to translate arrays of parameter  values to signal emissions into C language callback invocations or %NULL.
    @param return_type: the type of return value, or #G_TYPE_NONE for a signal  without a return value.
    @param n_params: the number of parameter types in @args.
    @param args: va_list of #GType, one for each parameter.
    @type signal_name: str
    @type itype: GType
    @type signal_flags: SignalFlags
    @type class_closure: Closure
    @type accumulator: SignalAccumulator
    @type accu_data: gpointer
    @type c_marshaller: SignalCMarshaller
    @type return_type: GType
    @type n_params: int
    @type args: va_list
    @returns: the signal id
    @rtype: int
    """
    return object

def signal_newv(signal_name=None, itype=None, signal_flags=None, class_closure=None, accumulator=None, accu_data=None, c_marshaller=None, return_type=None, n_params=None, param_types=None):
    """    Creates a new signal. (This is usually done in the class initializer.)
    
    See g_signal_new() for details on allowed signal names.
    
    If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
    the marshaller for this signal.
    @param signal_name: the name for the signal
    @param itype: the type this signal pertains to. It will also pertain to     types which are derived from this type
    @param signal_flags: a combination of #GSignalFlags specifying detail of when     the default handler is to be invoked. You should at least specify     %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST
    @param class_closure: The closure to invoke on signal emission;     may be %NULL
    @param accumulator: the accumulator for this signal; may be %NULL
    @param accu_data: user data for the @accumulator
    @param c_marshaller: the function to translate arrays of     parameter values to signal emissions into C language callback     invocations or %NULL
    @param return_type: the type of return value, or #G_TYPE_NONE for a signal     without a return value
    @param n_params: the length of @param_types
    @param param_types: an array of types, one for     each parameter
    @type signal_name: str
    @type itype: GType
    @type signal_flags: SignalFlags
    @type class_closure: Closure
    @type accumulator: SignalAccumulator
    @type accu_data: gpointer
    @type c_marshaller: SignalCMarshaller
    @type return_type: GType
    @type n_params: int
    @returns: the signal id
    @rtype: int
    """
    return object

def signal_override_class_closure(signal_id=None, instance_type=None, class_closure=None):
    """    Overrides the class closure (i.e. the default handler) for the given signal
    for emissions on instances of @instance_type. @instance_type must be derived
    from the type to which the signal belongs.
    
    See g_signal_chain_from_overridden() and
    g_signal_chain_from_overridden_handler() for how to chain up to the
    parent class closure from inside the overridden one.
    @param signal_id: the signal id
    @param instance_type: the instance type on which to override the class closure  for the signal.
    @param class_closure: the closure.
    @type signal_id: int
    @type instance_type: GType
    @type class_closure: Closure
    @returns: 
    @rtype: None
    """
    return object

def signal_override_class_handler(signal_name=None, instance_type=None, class_handler=None):
    """    Overrides the class closure (i.e. the default handler) for the
    given signal for emissions on instances of @instance_type with
    callback @class_handler. @instance_type must be derived from the
    type to which the signal belongs.
    
    See g_signal_chain_from_overridden() and
    g_signal_chain_from_overridden_handler() for how to chain up to the
    parent class closure from inside the overridden one.
    @param signal_name: the name for the signal
    @param instance_type: the instance type on which to override the class handler  for the signal.
    @param class_handler: the handler.
    @type signal_name: str
    @type instance_type: GType
    @type class_handler: Callback
    @returns: 
    @rtype: None
    """
    return object

def signal_parse_name(detailed_signal=None, itype=None, signal_id_p=None, detail_p=None, force_detail_quark=None):
    """    Internal function to parse a signal name into its @signal_id
    and @detail quark.
    @param detailed_signal: a string of the form "signal-name::detail".
    @param itype: The interface/instance type that introduced "signal-name".
    @param signal_id_p: Location to store the signal id.
    @param detail_p: Location to store the detail quark.
    @param force_detail_quark: %TRUE forces creation of a #GQuark for the detail.
    @type detailed_signal: str
    @type itype: GType
    @type signal_id_p: int
    @type detail_p: GLib.Quark
    @type force_detail_quark: bool
    @returns: Whether the signal name could successfully be parsed and @signal_id_p and @detail_p contain valid return values.
    @rtype: bool
    """
    return object

def signal_query(signal_id=None, query=None):
    """    Queries the signal system for in-depth information about a
    specific signal. This function will fill in a user-provided
    structure to hold signal-specific information. If an invalid
    signal id is passed in, the @signal_id member of the #GSignalQuery
    is 0. All members filled into the #GSignalQuery structure should
    be considered constant and have to be left untouched.
    @param signal_id: The signal id of the signal to query information for.
    @param query: A user provided structure that is  filled in with constant values upon success.
    @type signal_id: int
    @type query: SignalQuery
    @returns: 
    @rtype: None
    """
    return object

def signal_remove_emission_hook(signal_id=None, hook_id=None):
    """    Deletes an emission hook.
    @param signal_id: the id of the signal
    @param hook_id: the id of the emission hook, as returned by  g_signal_add_emission_hook()
    @type signal_id: int
    @type hook_id: long
    @returns: 
    @rtype: None
    """
    return object

def signal_set_va_marshaller(signal_id=None, instance_type=None, va_marshaller=None):
    """    Change the #GSignalCVaMarshaller used for a given signal.  This is a
    specialised form of the marshaller that can often be used for the
    common case of a single connected signal handler and avoids the
    overhead of #GValue.  Its use is optional.
    @param signal_id: the signal id
    @param instance_type: the instance type on which to set the marshaller.
    @param va_marshaller: the marshaller to set.
    @type signal_id: int
    @type instance_type: GType
    @type va_marshaller: SignalCVaMarshaller
    @returns: 
    @rtype: None
    """
    return object

def signal_stop_emission(instance=None, signal_id=None, detail=None):
    """    Stops a signal's current emission.
    
    This will prevent the default method from running, if the signal was
    %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after"
    flag).
    
    Prints a warning if used on a signal which isn't being emitted.
    @param instance: the object whose signal handlers you wish to stop.
    @param signal_id: the signal identifier, as returned by g_signal_lookup().
    @param detail: the detail which the signal was emitted with.
    @type instance: Object
    @type signal_id: int
    @type detail: GLib.Quark
    @returns: 
    @rtype: None
    """
    return object

def signal_stop_emission_by_name(instance=None, detailed_signal=None):
    """    Stops a signal's current emission.
    
    This is just like g_signal_stop_emission() except it will look up the
    signal id for you.
    @param instance: the object whose signal handlers you wish to stop.
    @param detailed_signal: a string of the form "signal-name::detail".
    @type instance: Object
    @type detailed_signal: str
    @returns: 
    @rtype: None
    """
    return object

def signal_type_cclosure_new(itype=None, struct_offset=None):
    """    Creates a new closure which invokes the function found at the offset
    @struct_offset in the class structure of the interface or classed type
    identified by @itype.
    @param itype: the #GType identifier of an interface or classed type
    @param struct_offset: the offset of the member function of @itype's class  structure which is to be invoked by the new closure
    @type itype: GType
    @type struct_offset: int
    @returns: a floating reference to a new #GCClosure
    @rtype: Closure
    """
    return object

def source_set_closure(source=None, closure=None):
    """    Set the callback for a source as a #GClosure.
    
    If the source is not one of the standard GLib types, the @closure_callback
    and @closure_marshal fields of the #GSourceFuncs structure must have been
    filled in with pointers to appropriate functions.
    @param source: the source
    @param closure: a #GClosure
    @type source: GLib.Source
    @type closure: Closure
    @returns: 
    @rtype: None
    """
    return object

def source_set_dummy_callback(source=None):
    """    Sets a dummy callback for @source. The callback will do nothing, and
    if the source expects a #gboolean return value, it will return %TRUE.
    (If the source expects any other type of return value, it will return
    a 0/%NULL value; whatever g_value_init() initializes a #GValue to for
    that type.)
    
    If the source is not one of the standard GLib types, the
    @closure_callback and @closure_marshal fields of the #GSourceFuncs
    structure must have been filled in with pointers to appropriate
    functions.
    @param source: the source
    @type source: GLib.Source
    @returns: 
    @rtype: None
    """
    return object

def strdup_value_contents(value=None):
    """    Return a newly allocated string, which describes the contents of a
    #GValue.  The main purpose of this function is to describe #GValue
    contents for debugging output, the way in which the contents are
    described may change between different GLib versions.
    @param value: #GValue which contents are to be described.
    @type value: Value
    @returns: Newly allocated string.
    @rtype: str
    """
    return object

def type_add_class_cache_func(cache_data=None, cache_func=None):
    """    Adds a #GTypeClassCacheFunc to be called before the reference count of a
    class goes from one to zero. This can be used to prevent premature class
    destruction. All installed #GTypeClassCacheFunc functions will be chained
    until one of them returns %TRUE. The functions have to check the class id
    passed in to figure whether they actually want to cache the class of this
    type, since all classes are routed through the same #GTypeClassCacheFunc
    chain.
    @param cache_data: data to be passed to @cache_func
    @param cache_func: a #GTypeClassCacheFunc
    @type cache_data: gpointer
    @type cache_func: TypeClassCacheFunc
    @returns: 
    @rtype: None
    """
    return object

def type_add_class_private(class_type=None, private_size=None):
    """    Registers a private class structure for a classed type;
    when the class is allocated, the private structures for
    the class and all of its parent types are allocated
    sequentially in the same memory block as the public
    structures, and are zero-filled.
    
    This function should be called in the
    type's get_type() function after the type is registered.
    The private structure can be retrieved using the
    G_TYPE_CLASS_GET_PRIVATE() macro.
    @param class_type: GType of an classed type
    @param private_size: size of private structure
    @type class_type: GType
    @type private_size: gsize
    @returns: 
    @rtype: None
    """
    return object

def type_add_instance_private(class_type=None, private_size=None):
    """    
    @type class_type: GType
    @type private_size: gsize
    @returns: 
    @rtype: int
    """
    return object

def type_add_interface_check(check_data=None, check_func=None):
    """    Adds a function to be called after an interface vtable is
    initialized for any class (i.e. after the @interface_init
    member of #GInterfaceInfo has been called).
    
    This function is useful when you want to check an invariant
    that depends on the interfaces of a class. For instance, the
    implementation of #GObject uses this facility to check that an
    object implements all of the properties that are defined on its
    interfaces.
    @param check_data: data to pass to @check_func
    @param check_func: function to be called after each interface     is initialized
    @type check_data: gpointer
    @type check_func: TypeInterfaceCheckFunc
    @returns: 
    @rtype: None
    """
    return object

def type_add_interface_dynamic(instance_type=None, interface_type=None, plugin=None):
    """    Adds the dynamic @interface_type to @instantiable_type. The information
    contained in the #GTypePlugin structure pointed to by @plugin
    is used to manage the relationship.
    @param instance_type: #GType value of an instantiable type
    @param interface_type: #GType value of an interface type
    @param plugin: #GTypePlugin structure to retrieve the #GInterfaceInfo from
    @type instance_type: GType
    @type interface_type: GType
    @type plugin: TypePlugin
    @returns: 
    @rtype: None
    """
    return object

def type_add_interface_static(instance_type=None, interface_type=None, info=None):
    """    Adds the static @interface_type to @instantiable_type.
    The information contained in the #GInterfaceInfo structure
    pointed to by @info is used to manage the relationship.
    @param instance_type: #GType value of an instantiable type
    @param interface_type: #GType value of an interface type
    @param info: #GInterfaceInfo structure for this        (@instance_type, @interface_type) combination
    @type instance_type: GType
    @type interface_type: GType
    @type info: InterfaceInfo
    @returns: 
    @rtype: None
    """
    return object

def type_check_class_cast(g_class=None, is_a_type=None):
    """    
    @type g_class: TypeClass
    @type is_a_type: GType
    @returns: 
    @rtype: TypeClass
    """
    return object

def type_check_class_is_a(g_class=None, is_a_type=None):
    """    
    @type g_class: TypeClass
    @type is_a_type: GType
    @returns: 
    @rtype: bool
    """
    return object

def type_check_instance(instance=None):
    """    Private helper function to aid implementation of the
    G_TYPE_CHECK_INSTANCE() macro.
    @param instance: a valid #GTypeInstance structure
    @type instance: TypeInstance
    @returns: %TRUE if @instance is valid, %FALSE otherwise
    @rtype: bool
    """
    return object

def type_check_instance_cast(instance=None, iface_type=None):
    """    
    @type instance: TypeInstance
    @type iface_type: GType
    @returns: 
    @rtype: TypeInstance
    """
    return object

def type_check_instance_is_a(instance=None, iface_type=None):
    """    
    @type instance: TypeInstance
    @type iface_type: GType
    @returns: 
    @rtype: bool
    """
    return object

def type_check_instance_is_fundamentally_a(instance=None, fundamental_type=None):
    """    
    @type instance: TypeInstance
    @type fundamental_type: GType
    @returns: 
    @rtype: bool
    """
    return object

def type_check_is_value_type(type=None):
    """    
    @type type: GType
    @returns: 
    @rtype: bool
    """
    return object

def type_check_value(value=None):
    """    
    @type value: Value
    @returns: 
    @rtype: bool
    """
    return object

def type_check_value_holds(value=None, type=None):
    """    
    @type value: Value
    @type type: GType
    @returns: 
    @rtype: bool
    """
    return object

def type_children(type=None, n_children=None):
    """    Return a newly allocated and 0-terminated array of type IDs, listing
    the child types of @type.
    @param type: the parent type
    @param n_children: location to store the length of     the returned array, or %NULL
    @type type: GType
    @type n_children: int
    @rtype: None
    """
    return object

def type_class_adjust_private_offset(g_class=None, private_size_or_offset=None):
    """    
    @type g_class: gpointer
    @type private_size_or_offset: int
    @returns: 
    @rtype: None
    """
    return object

def type_class_peek(type=None):
    """    This function is essentially the same as g_type_class_ref(),
    except that the classes reference count isn't incremented.
    As a consequence, this function may return %NULL if the class
    of the type passed in does not currently exist (hasn't been
    referenced before).
    @param type: type ID of a classed type
    @type type: GType
    @returns: the #GTypeClass
     structure for the given type ID or %NULL if the class does not
     currently exist
    @rtype: TypeClass
    """
    return object

def type_class_peek_static(type=None):
    """    A more efficient version of g_type_class_peek() which works only for
    static types.
    @param type: type ID of a classed type
    @type type: GType
    @returns: the #GTypeClass
     structure for the given type ID or %NULL if the class does not
     currently exist or is dynamically loaded
    @rtype: TypeClass
    """
    return object

def type_class_ref(type=None):
    """    Increments the reference count of the class structure belonging to
    @type. This function will demand-create the class if it doesn't
    exist already.
    @param type: type ID of a classed type
    @type type: GType
    @returns: the #GTypeClass
     structure for the given type ID
    @rtype: TypeClass
    """
    return object

def type_create_instance(type=None):
    """    Creates and initializes an instance of @type if @type is valid and
    can be instantiated. The type system only performs basic allocation
    and structure setups for instances: actual instance creation should
    happen through functions supplied by the type's fundamental type
    implementation.  So use of g_type_create_instance() is reserved for
    implementators of fundamental types only. E.g. instances of the
    #GObject hierarchy should be created via g_object_new() and never
    directly through g_type_create_instance() which doesn't handle things
    like singleton objects or object construction.
    
    The extended members of the returned instance are guaranteed to be filled
    with zeros.
    
    Note: Do not use this function, unless you're implementing a
    fundamental type. Also language bindings should not use this
    function, but g_object_new() instead.
    @param type: an instantiatable type to create an instance for
    @type type: GType
    @returns: an allocated and initialized instance, subject to further
     treatment by the fundamental type implementation
    @rtype: TypeInstance
    """
    return object

def type_default_interface_peek(g_type=None):
    """    If the interface type @g_type is currently in use, returns its
    default interface vtable.
    @param g_type: an interface type
    @type g_type: GType
    @returns: the default
     vtable for the interface, or %NULL if the type is not currently
     in use
    @rtype: TypeInterface
    """
    return object

def type_default_interface_ref(g_type=None):
    """    Increments the reference count for the interface type @g_type,
    and returns the default interface vtable for the type.
    
    If the type is not currently in use, then the default vtable
    for the type will be created and initalized by calling
    the base interface init and default vtable init functions for
    the type (the @base_init and @class_init members of #GTypeInfo).
    Calling g_type_default_interface_ref() is useful when you
    want to make sure that signals and properties for an interface
    have been installed.
    @param g_type: an interface type
    @type g_type: GType
    @returns: the default
     vtable for the interface; call g_type_default_interface_unref()
     when you are done using the interface.
    @rtype: TypeInterface
    """
    return object

def type_default_interface_unref(g_iface=None):
    """    Decrements the reference count for the type corresponding to the
    interface default vtable @g_iface. If the type is dynamic, then
    when no one is using the interface and all references have
    been released, the finalize function for the interface's default
    vtable (the @class_finalize member of #GTypeInfo) will be called.
    @param g_iface: the default vtable     structure for a interface, as returned by g_type_default_interface_ref()
    @type g_iface: TypeInterface
    @returns: 
    @rtype: None
    """
    return object

def type_depth(type=None):
    """    Returns the length of the ancestry of the passed in type. This
    includes the type itself, so that e.g. a fundamental type has depth 1.
    @param type: a #GType
    @type type: GType
    @returns: the depth of @type
    @rtype: int
    """
    return object

def type_ensure(type=None):
    """    Ensures that the indicated @type has been registered with the
    type system, and its _class_init() method has been run.
    
    In theory, simply calling the type's _get_type() method (or using
    the corresponding macro) is supposed take care of this. However,
    _get_type() methods are often marked %G_GNUC_CONST for performance
    reasons, even though this is technically incorrect (since
    %G_GNUC_CONST requires that the function not have side effects,
    which _get_type() methods do on the first call). As a result, if
    you write a bare call to a _get_type() macro, it may get optimized
    out by the compiler. Using g_type_ensure() guarantees that the
    type's _get_type() method is called.
    @param type: a #GType
    @type type: GType
    @returns: 
    @rtype: None
    """
    return object

def type_free_instance(instance=None):
    """    Frees an instance of a type, returning it to the instance pool for
    the type, if there is one.
    
    Like g_type_create_instance(), this function is reserved for
    implementors of fundamental types.
    @param instance: an instance of a type
    @type instance: TypeInstance
    @returns: 
    @rtype: None
    """
    return object

def type_from_name(name=None):
    """    Lookup the type ID from a given type name, returning 0 if no type
    has been registered under this name (this is the preferred method
    to find out by name whether a specific type has been registered
    yet).
    @param name: type name to lookup
    @type name: str
    @returns: corresponding type ID or 0
    @rtype: GType
    """
    return object

def type_fundamental(type_id=None):
    """    Internal function, used to extract the fundamental type ID portion.
    Use G_TYPE_FUNDAMENTAL() instead.
    @param type_id: valid type ID
    @type type_id: GType
    @returns: fundamental type ID
    @rtype: GType
    """
    return object

def type_fundamental_next():
    """    Returns the next free fundamental type id which can be used to
    register a new fundamental type with g_type_register_fundamental().
    The returned type ID represents the highest currently registered
    fundamental type identifier.
    @returns: the next available fundamental type ID to be registered,
     or 0 if the type system ran out of fundamental type IDs
    @rtype: GType
    """
    return object

def type_get_instance_count(type=None):
    """    Returns the number of instances allocated of the particular type;
    this is only available if GLib is built with debugging support and
    the instance_count debug flag is set (by setting the GOBJECT_DEBUG
    variable to include instance-count).
    @param type: a #GType
    @type type: GType
    @returns: the number of instances allocated of the given type;
   if instance counts are not available, returns 0.
    @rtype: int
    """
    return object

def type_get_plugin(type=None):
    """    Returns the #GTypePlugin structure for @type.
    @param type: #GType to retrieve the plugin for
    @type type: GType
    @returns: the corresponding plugin
     if @type is a dynamic type, %NULL otherwise
    @rtype: TypePlugin
    """
    return object

def type_get_qdata(type=None, quark=None):
    """    Obtains data which has previously been attached to @type
    with g_type_set_qdata().
    
    Note that this does not take subtyping into account; data
    attached to one type with g_type_set_qdata() cannot
    be retrieved from a subtype using g_type_get_qdata().
    @param type: a #GType
    @param quark: a #GQuark id to identify the data
    @type type: GType
    @type quark: GLib.Quark
    @returns: the data, or %NULL if no data was found
    @rtype: gpointer
    """
    return object

def type_get_type_registration_serial():
    """    Returns an opaque serial number that represents the state of the set
    of registered types. Any time a type is registered this serial changes,
    which means you can cache information based on type lookups (such as
    g_type_from_name()) and know if the cache is still valid at a later
    time by comparing the current serial with the one at the type lookup.
    @returns: An unsigned int, representing the state of type registrations
    @rtype: int
    """
    return object

def type_init():
    """    This function used to initialise the type system.  Since GLib 2.36,
    the type system is initialised automatically and this function does
    nothing.
    @returns: 
    @rtype: None
    """
    return object

def type_init_with_debug_flags(debug_flags=None):
    """    This function used to initialise the type system with debugging
    flags.  Since GLib 2.36, the type system is initialised automatically
    and this function does nothing.
    
    If you need to enable debugging features, use the GOBJECT_DEBUG
    environment variable.
    @param debug_flags: bitwise combination of #GTypeDebugFlags values for     debugging purposes
    @type debug_flags: TypeDebugFlags
    @returns: 
    @rtype: None
    """
    return object

def type_interface_add_prerequisite(interface_type=None, prerequisite_type=None):
    """    Adds @prerequisite_type to the list of prerequisites of @interface_type.
    This means that any type implementing @interface_type must also implement
    @prerequisite_type. Prerequisites can be thought of as an alternative to
    interface derivation (which GType doesn't support). An interface can have
    at most one instantiatable prerequisite type.
    @param interface_type: #GType value of an interface type
    @param prerequisite_type: #GType value of an interface or instantiatable type
    @type interface_type: GType
    @type prerequisite_type: GType
    @returns: 
    @rtype: None
    """
    return object

def type_interface_get_plugin(instance_type=None, interface_type=None):
    """    Returns the #GTypePlugin structure for the dynamic interface
    @interface_type which has been added to @instance_type, or %NULL
    if @interface_type has not been added to @instance_type or does
    not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
    @param instance_type: #GType of an instantiatable type
    @param interface_type: #GType of an interface type
    @type instance_type: GType
    @type interface_type: GType
    @returns: the #GTypePlugin for the dynamic
     interface @interface_type of @instance_type
    @rtype: TypePlugin
    """
    return object

def type_interface_peek(instance_class=None, iface_type=None):
    """    Returns the #GTypeInterface structure of an interface to which the
    passed in class conforms.
    @param instance_class: a #GTypeClass structure
    @param iface_type: an interface ID which this class conforms to
    @type instance_class: TypeClass
    @type iface_type: GType
    @returns: the #GTypeInterface
     structure of @iface_type if implemented by @instance_class, %NULL
     otherwise
    @rtype: TypeInterface
    """
    return object

def type_interface_prerequisites(interface_type=None, n_prerequisites=None):
    """    Returns the prerequisites of an interfaces type.
    @param interface_type: an interface type
    @param n_prerequisites: location to return the number     of prerequisites, or %NULL
    @type interface_type: GType
    @type n_prerequisites: int
    @rtype: None
    """
    return object

def type_interfaces(type=None, n_interfaces=None):
    """    Return a newly allocated and 0-terminated array of type IDs, listing
    the interface types that @type conforms to.
    @param type: the type to list interface types for
    @param n_interfaces: location to store the length of     the returned array, or %NULL
    @type type: GType
    @type n_interfaces: int
    @rtype: None
    """
    return object

def type_is_a(type=None, is_a_type=None):
    """    If @is_a_type is a derivable type, check whether @type is a
    descendant of @is_a_type. If @is_a_type is an interface, check
    whether @type conforms to it.
    @param type: type to check anchestry for
    @param is_a_type: possible anchestor of @type or interface that @type     could conform to
    @type type: GType
    @type is_a_type: GType
    @returns: %TRUE if @type is a @is_a_type
    @rtype: bool
    """
    return object

def type_name(type=None):
    """    Get the unique name that is assigned to a type ID.  Note that this
    function (like all other GType API) cannot cope with invalid type
    IDs. %G_TYPE_INVALID may be passed to this function, as may be any
    other validly registered type ID, but randomized type IDs should
    not be passed in and will most likely lead to a crash.
    @param type: type to return name for
    @type type: GType
    @returns: static type name or %NULL
    @rtype: str
    """
    return object

def type_name_from_class(g_class=None):
    """    
    @type g_class: TypeClass
    @returns: 
    @rtype: str
    """
    return object

def type_name_from_instance(instance=None):
    """    
    @type instance: TypeInstance
    @returns: 
    @rtype: str
    """
    return object

def type_next_base(leaf_type=None, root_type=None):
    """    Given a @leaf_type and a @root_type which is contained in its
    anchestry, return the type that @root_type is the immediate parent
    of. In other words, this function determines the type that is
    derived directly from @root_type which is also a base class of
    @leaf_type.  Given a root type and a leaf type, this function can
    be used to determine the types and order in which the leaf type is
    descended from the root type.
    @param leaf_type: descendant of @root_type and the type to be returned
    @param root_type: immediate parent of the returned type
    @type leaf_type: GType
    @type root_type: GType
    @returns: immediate child of @root_type and anchestor of @leaf_type
    @rtype: GType
    """
    return object

def type_parent(type=None):
    """    Return the direct parent type of the passed in type. If the passed
    in type has no parent, i.e. is a fundamental type, 0 is returned.
    @param type: the derived type
    @type type: GType
    @returns: the parent type
    @rtype: GType
    """
    return object

def type_qname(type=None):
    """    Get the corresponding quark of the type IDs name.
    @param type: type to return quark of type name for
    @type type: GType
    @returns: the type names quark or 0
    @rtype: GLib.Quark
    """
    return object

def type_query(type=None, query=None):
    """    Queries the type system for information about a specific type.
    This function will fill in a user-provided structure to hold
    type-specific information. If an invalid #GType is passed in, the
    @type member of the #GTypeQuery is 0. All members filled into the
    #GTypeQuery structure should be considered constant and have to be
    left untouched.
    @param type: #GType of a static, classed type
    @param query: a user provided structure that is     filled in with constant values upon success
    @type type: GType
    @type query: TypeQuery
    @returns: 
    @rtype: None
    """
    return object

def type_register_dynamic(parent_type=None, type_name=None, plugin=None, flags=None):
    """    Registers @type_name as the name of a new dynamic type derived from
    @parent_type.  The type system uses the information contained in the
    #GTypePlugin structure pointed to by @plugin to manage the type and its
    instances (if not abstract).  The value of @flags determines the nature
    (e.g. abstract or not) of the type.
    @param parent_type: type from which this type will be derived
    @param type_name: 0-terminated string used as the name of the new type
    @param plugin: #GTypePlugin structure to retrieve the #GTypeInfo from
    @param flags: bitwise combination of #GTypeFlags values
    @type parent_type: GType
    @type type_name: str
    @type plugin: TypePlugin
    @type flags: TypeFlags
    @returns: the new type identifier or #G_TYPE_INVALID if registration failed
    @rtype: GType
    """
    return object

def type_register_fundamental(type_id=None, type_name=None, info=None, finfo=None, flags=None):
    """    Registers @type_id as the predefined identifier and @type_name as the
    name of a fundamental type. If @type_id is already registered, or a
    type named @type_name is already registered, the behaviour is undefined.
    The type system uses the information contained in the #GTypeInfo structure
    pointed to by @info and the #GTypeFundamentalInfo structure pointed to by
    @finfo to manage the type and its instances. The value of @flags determines
    additional characteristics of the fundamental type.
    @param type_id: a predefined type identifier
    @param type_name: 0-terminated string used as the name of the new type
    @param info: #GTypeInfo structure for this type
    @param finfo: #GTypeFundamentalInfo structure for this type
    @param flags: bitwise combination of #GTypeFlags values
    @type type_id: GType
    @type type_name: str
    @type info: TypeInfo
    @type finfo: TypeFundamentalInfo
    @type flags: TypeFlags
    @returns: the predefined type identifier
    @rtype: GType
    """
    return object

def type_register_static(parent_type=None, type_name=None, info=None, flags=None):
    """    Registers @type_name as the name of a new static type derived from
    @parent_type. The type system uses the information contained in the
    #GTypeInfo structure pointed to by @info to manage the type and its
    instances (if not abstract). The value of @flags determines the nature
    (e.g. abstract or not) of the type.
    @param parent_type: type from which this type will be derived
    @param type_name: 0-terminated string used as the name of the new type
    @param info: #GTypeInfo structure for this type
    @param flags: bitwise combination of #GTypeFlags values
    @type parent_type: GType
    @type type_name: str
    @type info: TypeInfo
    @type flags: TypeFlags
    @returns: the new type identifier
    @rtype: GType
    """
    return object

def type_register_static_simple(parent_type=None, type_name=None, class_size=None, class_init=None, instance_size=None, instance_init=None, flags=None):
    """    Registers @type_name as the name of a new static type derived from
    @parent_type.  The value of @flags determines the nature (e.g.
    abstract or not) of the type. It works by filling a #GTypeInfo
    struct and calling g_type_register_static().
    @param parent_type: type from which this type will be derived
    @param type_name: 0-terminated string used as the name of the new type
    @param class_size: size of the class structure (see #GTypeInfo)
    @param class_init: location of the class initialization function (see #GTypeInfo)
    @param instance_size: size of the instance structure (see #GTypeInfo)
    @param instance_init: location of the instance initialization function (see #GTypeInfo)
    @param flags: bitwise combination of #GTypeFlags values
    @type parent_type: GType
    @type type_name: str
    @type class_size: int
    @type class_init: ClassInitFunc
    @type instance_size: int
    @type instance_init: InstanceInitFunc
    @type flags: TypeFlags
    @returns: the new type identifier
    @rtype: GType
    """
    return object

def type_remove_class_cache_func(cache_data=None, cache_func=None):
    """    Removes a previously installed #GTypeClassCacheFunc. The cache
    maintained by @cache_func has to be empty when calling
    g_type_remove_class_cache_func() to avoid leaks.
    @param cache_data: data that was given when adding @cache_func
    @param cache_func: a #GTypeClassCacheFunc
    @type cache_data: gpointer
    @type cache_func: TypeClassCacheFunc
    @returns: 
    @rtype: None
    """
    return object

def type_remove_interface_check(check_data=None, check_func=None):
    """    Removes an interface check function added with
    g_type_add_interface_check().
    @param check_data: callback data passed to g_type_add_interface_check()
    @param check_func: callback function passed to g_type_add_interface_check()
    @type check_data: gpointer
    @type check_func: TypeInterfaceCheckFunc
    @returns: 
    @rtype: None
    """
    return object

def type_set_qdata(type=None, quark=None, data=None):
    """    Attaches arbitrary data to a type.
    @param type: a #GType
    @param quark: a #GQuark id to identify the data
    @param data: the data
    @type type: GType
    @type quark: GLib.Quark
    @type data: gpointer
    @returns: 
    @rtype: None
    """
    return object

def type_test_flags(type=None, flags=None):
    """    
    @type type: GType
    @type flags: int
    @returns: 
    @rtype: bool
    """
    return object

def type_value_table_peek(type=None):
    """    Returns the location of the #GTypeValueTable associated with @type.
    
    Note that this function should only be used from source code
    that implements or has internal knowledge of the implementation of
    @type.
    @param type: a #GType
    @type type: GType
    @returns: location of the #GTypeValueTable associated with @type or
     %NULL if there is no #GTypeValueTable associated with @type
    @rtype: TypeValueTable
    """
    return object

def value_register_transform_func(src_type=None, dest_type=None, transform_func=None):
    """    Registers a value transformation function for use in g_value_transform().
    A previously registered transformation function for @src_type and @dest_type
    will be replaced.
    @param src_type: Source type.
    @param dest_type: Target type.
    @param transform_func: a function which transforms values of type @src_type  into value of type @dest_type
    @type src_type: GType
    @type dest_type: GType
    @type transform_func: ValueTransform
    @returns: 
    @rtype: None
    """
    return object

def value_type_compatible(src_type=None, dest_type=None):
    """    Returns whether a #GValue of type @src_type can be copied into
    a #GValue of type @dest_type.
    @param src_type: source type to be copied.
    @param dest_type: destination type for copying.
    @type src_type: GType
    @type dest_type: GType
    @returns: %TRUE if g_value_copy() is possible with @src_type and @dest_type.
    @rtype: bool
    """
    return object

def value_type_transformable(src_type=None, dest_type=None):
    """    Check whether g_value_transform() is able to transform values
    of type @src_type into values of type @dest_type. Note that for
    the types to be transformable, they must be compatible or a
    transformation function must be registered.
    @param src_type: Source type.
    @param dest_type: Target type.
    @type src_type: GType
    @type dest_type: GType
    @returns: %TRUE if the transformation is possible, %FALSE otherwise.
    @rtype: bool
    """
    return object


class CClosure():
    """A #GCClosure is a specialization of #GClosure for C function callbacks."""
    @staticmethod
    def marshal_BOOLEAN__BOXED_BOXED(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with handlers that
        take two boxed pointers as arguments and return a boolean.  If you
        have such a signal, you will probably also need to use an
        accumulator, such as g_signal_accumulator_true_handled().
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_BOOLEAN__BOXED_BOXEDv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__BOXED_BOXED().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_BOOLEAN__FLAGS(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with handlers that
        take a flags type as an argument and return a boolean.  If you have
        such a signal, you will probably also need to use an accumulator,
        such as g_signal_accumulator_true_handled().
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_BOOLEAN__FLAGSv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_BOOLEAN__FLAGS().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_STRING__OBJECT_POINTER(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with handlers that
        take a #GObject and a pointer and produce a string.  It is highly
        unlikely that your signal handler fits this description.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_STRING__OBJECT_POINTERv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_STRING__OBJECT_POINTER().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__BOOLEAN(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        boolean argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__BOOLEANv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOOLEAN().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__BOXED(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        argument which is any boxed pointer type.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__BOXEDv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__BOXED().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__CHAR(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        character argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__CHARv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__CHAR().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__DOUBLE(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with one
        double-precision floating point argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__DOUBLEv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__DOUBLE().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__ENUM(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        argument with an enumerated type.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__ENUMv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ENUM().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__FLAGS(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        argument with a flags types.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__FLAGSv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLAGS().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__FLOAT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with one
        single-precision floating point argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__FLOATv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__FLOAT().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__INT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        integer argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__INTv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__INT().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__LONG(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with with a single
        long integer argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__LONGv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__LONG().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__OBJECT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        #GObject argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__OBJECTv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__OBJECT().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__PARAM(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        argument of type #GParamSpec.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__PARAMv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__PARAM().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__POINTER(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single raw
        pointer argument type.
        
        If it is possible, it is better to use one of the more specific
        functions such as g_cclosure_marshal_VOID__OBJECT() or
        g_cclosure_marshal_VOID__OBJECT().
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__POINTERv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__POINTER().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__STRING(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single string
        argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__STRINGv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__STRING().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__UCHAR(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        unsigned character argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__UCHARv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UCHAR().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__UINT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with with a single
        unsigned integer argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__UINT_POINTER(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a unsigned int
        and a pointer as arguments.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__UINT_POINTERv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT_POINTER().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__UINTv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__UINT().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__ULONG(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        unsigned long integer argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__ULONGv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__ULONG().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__VARIANT(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with a single
        #GVariant argument.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__VARIANTv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VARIANT().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__VOID(closure=None, return_value=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A #GClosureMarshal function for use with signals with no arguments.
        @param closure: A #GClosure.
        @param return_value: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_value: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_VOID__VOIDv(closure=None, return_value=None, instance=None, args=None, marshal_data=None, n_params=None, param_types=None):
        """        The #GVaClosureMarshal equivalent to g_cclosure_marshal_VOID__VOID().
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is invoked.
        @param args: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_generic(closure=None, return_gvalue=None, n_param_values=None, param_values=None, invocation_hint=None, marshal_data=None):
        """        A generic marshaller function implemented via
        [libffi](http://sourceware.org/libffi/).
        
        Normally this function is not passed explicitly to g_signal_new(),
        but used automatically by GLib when specifying a %NULL marshaller.
        @param closure: A #GClosure.
        @param return_gvalue: A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
        @param n_param_values: The length of the @param_values array.
        @param param_values: An array of #GValues holding the arguments   on which to invoke the callback of closure.
        @param invocation_hint: The invocation hint given as the last argument to   g_closure_invoke().
        @param marshal_data: Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
        @type closure: Closure
        @type return_gvalue: Value
        @type n_param_values: int
        @type param_values: Value
        @type invocation_hint: gpointer
        @type marshal_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def marshal_generic_va(closure=None, return_value=None, instance=None, args_list=None, marshal_data=None, n_params=None, param_types=None):
        """        A generic #GVaClosureMarshal function implemented via
        [libffi](http://sourceware.org/libffi/).
        @param closure: the #GClosure to which the marshaller belongs
        @param return_value: a #GValue to store the return  value. May be %NULL if the callback of @closure doesn't return a  value.
        @param instance: the instance on which the closure is  invoked.
        @param args_list: va_list of arguments to be passed to the closure.
        @param marshal_data: additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
        @param n_params: the length of the @param_types array
        @param param_types: the #GType of each argument from  @args_list.
        @type closure: Closure
        @type return_value: Value
        @type instance: TypeInstance
        @type args_list: va_list
        @type marshal_data: gpointer
        @type n_params: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def new(callback_func=None, user_data=None, destroy_data=None):
        """        Creates a new closure which invokes @callback_func with @user_data as
        the last parameter.
        @param callback_func: the function to invoke
        @param user_data: user data to pass to @callback_func
        @param destroy_data: destroy notify to be called when @user_data is no longer used
        @type callback_func: Callback
        @type user_data: gpointer
        @type destroy_data: ClosureNotify
        @returns: a floating reference to a new #GCClosure
        @rtype: Closure
        """
        return object
    @staticmethod
    def new_object(callback_func=None, object=None):
        """        A variant of g_cclosure_new() which uses @object as @user_data and
        calls g_object_watch_closure() on @object and the created
        closure. This function is useful when you have a callback closely
        associated with a #GObject, and want the callback to no longer run
        after the object is is freed.
        @param callback_func: the function to invoke
        @param object: a #GObject pointer to pass to @callback_func
        @type callback_func: Callback
        @type object: Object
        @returns: a new #GCClosure
        @rtype: Closure
        """
        return object
    @staticmethod
    def new_object_swap(callback_func=None, object=None):
        """        A variant of g_cclosure_new_swap() which uses @object as @user_data
        and calls g_object_watch_closure() on @object and the created
        closure. This function is useful when you have a callback closely
        associated with a #GObject, and want the callback to no longer run
        after the object is is freed.
        @param callback_func: the function to invoke
        @param object: a #GObject pointer to pass to @callback_func
        @type callback_func: Callback
        @type object: Object
        @returns: a new #GCClosure
        @rtype: Closure
        """
        return object
    @staticmethod
    def new_swap(callback_func=None, user_data=None, destroy_data=None):
        """        Creates a new closure which invokes @callback_func with @user_data as
        the first parameter.
        @param callback_func: the function to invoke
        @param user_data: user data to pass to @callback_func
        @param destroy_data: destroy notify to be called when @user_data is no longer used
        @type callback_func: Callback
        @type user_data: gpointer
        @type destroy_data: ClosureNotify
        @returns: a floating reference to a new #GCClosure
        @rtype: Closure
        """
        return object

    @property
    def closure(self):
        return object

    @property
    def callback(self):
        return object


class Closure():
    """A #GClosure represents a callback supplied by the programmer. It
will generally comprise a function of some kind and a marshaller
used to call it. It is the responsibility of the marshaller to
convert the arguments for the invocation from #GValues into
a suitable form, perform the callback on the converted arguments,
and transform the return value back into a #GValue.

In the case of C programs, a closure usually just holds a pointer
to a function and maybe a data argument, and the marshaller
converts between #GValue and native C types. The GObject
library provides the #GCClosure type for this purpose. Bindings for
other languages need marshallers which convert between #GValues
and suitable representations in the runtime of the language in
order to use functions written in that languages as callbacks.

Within GObject, closures play an important role in the
implementation of signals. When a signal is registered, the
@c_marshaller argument to g_signal_new() specifies the default C
marshaller for any closure which is connected to this
signal. GObject provides a number of C marshallers for this
purpose, see the g_cclosure_marshal_*() functions. Additional C
marshallers can be generated with the [glib-genmarshal][glib-genmarshal]
utility.  Closures can be explicitly connected to signals with
g_signal_connect_closure(), but it usually more convenient to let
GObject create a closure automatically by using one of the
g_signal_connect_*() functions which take a callback function/user
data pair.

Using closures has a number of important advantages over a simple
callback function/data pointer combination:

- Closures allow the callee to get the types of the callback parameters,
  which means that language bindings don't have to write individual glue
  for each callback type.

- The reference counting of #GClosure makes it easy to handle reentrancy
  right; if a callback is removed while it is being invoked, the closure
  and its parameters won't be freed until the invocation finishes.

- g_closure_invalidate() and invalidation notifiers allow callbacks to be
  automatically removed when the objects they point to go away."""
    @staticmethod
    def new_object(sizeof_closure=None, object=None):
        """        A variant of g_closure_new_simple() which stores @object in the
        @data field of the closure and calls g_object_watch_closure() on
        @object and the created closure. This function is mainly useful
        when implementing new types of closures.
        @param sizeof_closure: the size of the structure to allocate, must be at least  `sizeof (GClosure)`
        @param object: a #GObject pointer to store in the @data field of the newly  allocated #GClosure
        @type sizeof_closure: int
        @type object: Object
        @returns: Newly created Closure
        @rtype: Closure
        """
        return object
    @staticmethod
    def new_simple(sizeof_closure=None, data=None):
        """        Allocates a struct of the given size and initializes the initial
        part as a #GClosure. This function is mainly useful when
        implementing new types of closures.
        
        |[<!-- language="C" -->
        typedef struct _MyClosure MyClosure;
        struct _MyClosure
        {
          GClosure closure;
          // extra data goes here
        };
        
        static void
        my_closure_finalize (gpointer  notify_data,
                             GClosure *closure)
        {
          MyClosure *my_closure = (MyClosure *)closure;
        
          // free extra data here
        }
        
        MyClosure *my_closure_new (gpointer data)
        {
          GClosure *closure;
          MyClosure *my_closure;
        
          closure = g_closure_new_simple (sizeof (MyClosure), data);
          my_closure = (MyClosure *) closure;
        
          // initialize extra data here
        
          g_closure_add_finalize_notifier (closure, notify_data,
                                           my_closure_finalize);
          return my_closure;
        }
        ]|
        @param sizeof_closure: the size of the structure to allocate, must be at least                  `sizeof (GClosure)`
        @param data: data to store in the @data field of the newly allocated #GClosure
        @type sizeof_closure: int
        @type data: gpointer
        @returns: Newly created Closure
        @rtype: Closure
        """
        return object
    
    def add_finalize_notifier(self, notify_data=None, notify_func=None):
        """        Registers a finalization notifier which will be called when the
        reference count of @closure goes down to 0. Multiple finalization
        notifiers on a single closure are invoked in unspecified order. If
        a single call to g_closure_unref() results in the closure being
        both invalidated and finalized, then the invalidate notifiers will
        be run before the finalize notifiers.
        @param notify_data: data to pass to @notify_func
        @param notify_func: the callback function to register
        @type notify_data: gpointer
        @type notify_func: ClosureNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def add_invalidate_notifier(self, notify_data=None, notify_func=None):
        """        Registers an invalidation notifier which will be called when the
        @closure is invalidated with g_closure_invalidate(). Invalidation
        notifiers are invoked before finalization notifiers, in an
        unspecified order.
        @param notify_data: data to pass to @notify_func
        @param notify_func: the callback function to register
        @type notify_data: gpointer
        @type notify_func: ClosureNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def add_marshal_guards(self, pre_marshal_data=None, pre_marshal_notify=None, post_marshal_data=None, post_marshal_notify=None):
        """        Adds a pair of notifiers which get invoked before and after the
        closure callback, respectively. This is typically used to protect
        the extra arguments for the duration of the callback. See
        g_object_watch_closure() for an example of marshal guards.
        @param pre_marshal_data: data to pass  to @pre_marshal_notify
        @param pre_marshal_notify: a function to call before the closure callback
        @param post_marshal_data: data to pass  to @post_marshal_notify
        @param post_marshal_notify: a function to call after the closure callback
        @type pre_marshal_data: gpointer
        @type pre_marshal_notify: ClosureNotify
        @type post_marshal_data: gpointer
        @type post_marshal_notify: ClosureNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def invalidate(self):
        """        Sets a flag on the closure to indicate that its calling
        environment has become invalid, and thus causes any future
        invocations of g_closure_invoke() on this @closure to be
        ignored. Also, invalidation notifiers installed on the closure will
        be called at this point. Note that unless you are holding a
        reference to the closure yourself, the invalidation notifiers may
        unref the closure and cause it to be destroyed, so if you need to
        access the closure after calling g_closure_invalidate(), make sure
        that you've previously called g_closure_ref().
        
        Note that g_closure_invalidate() will also be called when the
        reference count of a closure drops to zero (unless it has already
        been invalidated before).
        @returns: 
        @rtype: None
        """
        return object
    
    def invoke(self, return_value=None, n_param_values=None, param_values=None, invocation_hint=None):
        """        Invokes the closure, i.e. executes the callback represented by the @closure.
        @param return_value: a #GValue to store the return                value. May be %NULL if the callback of @closure                doesn't return a value.
        @param n_param_values: the length of the @param_values array
        @param param_values: an array of                #GValues holding the arguments on which to                invoke the callback of @closure
        @param invocation_hint: a context-dependent invocation hint
        @type return_value: Value
        @type n_param_values: int
        @type invocation_hint: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def ref(self):
        """        Increments the reference count on a closure to force it staying
        alive while the caller holds a pointer to it.
        @returns: The @closure passed in, for convenience
        @rtype: Closure
        """
        return object
    
    def remove_finalize_notifier(self, notify_data=None, notify_func=None):
        """        Removes a finalization notifier.
        
        Notice that notifiers are automatically removed after they are run.
        @param notify_data: data which was passed to g_closure_add_finalize_notifier()  when registering @notify_func
        @param notify_func: the callback function to remove
        @type notify_data: gpointer
        @type notify_func: ClosureNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def remove_invalidate_notifier(self, notify_data=None, notify_func=None):
        """        Removes an invalidation notifier.
        
        Notice that notifiers are automatically removed after they are run.
        @param notify_data: data which was passed to g_closure_add_invalidate_notifier()               when registering @notify_func
        @param notify_func: the callback function to remove
        @type notify_data: gpointer
        @type notify_func: ClosureNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def set_marshal(self, marshal=None):
        """        Sets the marshaller of @closure. The `marshal_data`
        of @marshal provides a way for a meta marshaller to provide additional
        information to the marshaller. (See g_closure_set_meta_marshal().) For
        GObject's C predefined marshallers (the g_cclosure_marshal_*()
        functions), what it provides is a callback function to use instead of
        @closure->callback.
        @param marshal: a #GClosureMarshal function
        @type marshal: ClosureMarshal
        @returns: 
        @rtype: None
        """
        return object
    
    def set_meta_marshal(self, marshal_data=None, meta_marshal=None):
        """        Sets the meta marshaller of @closure.  A meta marshaller wraps
        @closure->marshal and modifies the way it is called in some
        fashion. The most common use of this facility is for C callbacks.
        The same marshallers (generated by [glib-genmarshal][glib-genmarshal]),
        are used everywhere, but the way that we get the callback function
        differs. In most cases we want to use @closure->callback, but in
        other cases we want to use some different technique to retrieve the
        callback function.
        
        For example, class closures for signals (see
        g_signal_type_cclosure_new()) retrieve the callback function from a
        fixed offset in the class structure.  The meta marshaller retrieves
        the right callback and passes it to the marshaller as the
        @marshal_data argument.
        @param marshal_data: context-dependent data to pass  to @meta_marshal
        @param meta_marshal: a #GClosureMarshal function
        @type marshal_data: gpointer
        @type meta_marshal: ClosureMarshal
        @returns: 
        @rtype: None
        """
        return object
    
    def sink(self):
        """        Takes over the initial ownership of a closure.  Each closure is
        initially created in a "floating" state, which means that the initial
        reference count is not owned by any caller. g_closure_sink() checks
        to see if the object is still floating, and if so, unsets the
        floating state and decreases the reference count. If the closure
        is not floating, g_closure_sink() does nothing. The reason for the
        existence of the floating state is to prevent cumbersome code
        sequences like:
        |[<!-- language="C" -->
        closure = g_cclosure_new (cb_func, cb_data);
        g_source_set_closure (source, closure);
        g_closure_unref (closure); // GObject doesn't really need this
        ]|
        Because g_source_set_closure() (and similar functions) take ownership of the
        initial reference count, if it is unowned, we instead can write:
        |[<!-- language="C" -->
        g_source_set_closure (source, g_cclosure_new (cb_func, cb_data));
        ]|
        
        Generally, this function is used together with g_closure_ref(). Ane example
        of storing a closure for later notification looks like:
        |[<!-- language="C" -->
        static GClosure *notify_closure = NULL;
        void
        foo_notify_set_closure (GClosure *closure)
        {
          if (notify_closure)
            g_closure_unref (notify_closure);
          notify_closure = closure;
          if (notify_closure)
            {
              g_closure_ref (notify_closure);
              g_closure_sink (notify_closure);
            }
        }
        ]|
        
        Because g_closure_sink() may decrement the reference count of a closure
        (if it hasn't been called on @closure yet) just like g_closure_unref(),
        g_closure_ref() should be called prior to this function.
        @returns: 
        @rtype: None
        """
        return object
    
    def unref(self):
        """        Decrements the reference count of a closure after it was previously
        incremented by the same caller. If no other callers are using the
        closure, then the closure will be destroyed and freed.
        @returns: 
        @rtype: None
        """
        return object

    @property
    def ref_count(self):
        return object

    @property
    def meta_marshal_nouse(self):
        return object

    @property
    def n_guards(self):
        return object

    @property
    def n_fnotifiers(self):
        return object

    @property
    def n_inotifiers(self):
        return object

    @property
    def in_inotify(self):
        return object

    @property
    def floating(self):
        return object

    @property
    def derivative_flag(self):
        return object

    @property
    def in_marshal(self):
        return object

    @property
    def is_invalid(self):
        return object

    @property
    def marshal(self):
        return object

    @property
    def data(self):
        return object

    @property
    def notifiers(self):
        return object


class ClosureNotifyData():
    """"""

    @property
    def data(self):
        return object

    @property
    def notify(self):
        return object


class EnumClass():
    """The class of an enumeration type holds information about its
possible values."""

    @property
    def g_type_class(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def n_values(self):
        return object

    @property
    def values(self):
        return object


class EnumValue():
    """A structure which contains a single enum value, its name, and its
nickname."""

    @property
    def value(self):
        return object

    @property
    def value_name(self):
        return object

    @property
    def value_nick(self):
        return object


class FlagsClass():
    """The class of a flags type holds information about its
possible values."""

    @property
    def g_type_class(self):
        return object

    @property
    def mask(self):
        return object

    @property
    def n_values(self):
        return object

    @property
    def values(self):
        return object


class FlagsValue():
    """A structure which contains a single flags value, its name, and its
nickname."""

    @property
    def value(self):
        return object

    @property
    def value_name(self):
        return object

    @property
    def value_nick(self):
        return object


class InitiallyUnownedClass():
    """The class structure for the GInitiallyUnowned type."""

    @property
    def g_type_class(self):
        return object

    @property
    def construct_properties(self):
        return object

    @property
    def constructor(self):
        return object

    @property
    def set_property(self):
        return object

    @property
    def get_property(self):
        return object

    @property
    def dispose(self):
        return object

    @property
    def finalize(self):
        return object

    @property
    def dispatch_properties_changed(self):
        return object

    @property
    def notify(self):
        return object

    @property
    def constructed(self):
        return object

    @property
    def flags(self):
        return object

    @property
    def pdummy(self):
        return object


class InterfaceInfo():
    """A structure that provides information to the type system which is
used specifically for managing interface types."""

    @property
    def interface_init(self):
        return object

    @property
    def interface_finalize(self):
        return object

    @property
    def interface_data(self):
        return object


class Object():
    """All the fields in the GObject structure are private
to the #GObject implementation and should never be accessed directly."""
    
    def __init__(self, object_type=None, first_property_name=None, *args):
        """        Creates a new instance of a #GObject subtype and sets its properties.
        
        Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
        which are not explicitly specified are set to their default values.
        @param object_type: the type id of the #GObject subtype to instantiate
        @param first_property_name: the name of the first property
        @param *args: the value of the first property, followed optionally by more  name/value pairs, followed by %NULL
        @type object_type: GType
        @type first_property_name: str
        @returns: Newly created Object
        @rtype: Object
        """
        return object
    @staticmethod
    def new(object_type=None, first_property_name=None, *args):
        """        Creates a new instance of a #GObject subtype and sets its properties.
        
        Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
        which are not explicitly specified are set to their default values.
        @param object_type: the type id of the #GObject subtype to instantiate
        @param first_property_name: the name of the first property
        @param *args: the value of the first property, followed optionally by more  name/value pairs, followed by %NULL
        @type object_type: GType
        @type first_property_name: str
        @returns: Newly created Object
        @rtype: Object
        """
        return object
    @staticmethod
    def new_valist(object_type=None, first_property_name=None, var_args=None):
        """        Creates a new instance of a #GObject subtype and sets its properties.
        
        Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
        which are not explicitly specified are set to their default values.
        @param object_type: the type id of the #GObject subtype to instantiate
        @param first_property_name: the name of the first property
        @param var_args: the value of the first property, followed optionally by more  name/value pairs, followed by %NULL
        @type object_type: GType
        @type first_property_name: str
        @type var_args: va_list
        @returns: Newly created Object
        @rtype: Object
        """
        return object
    @staticmethod
    def new_with_properties(object_type=None, n_properties=None, names=None, values=None):
        """        Creates a new instance of a #GObject subtype and sets its properties using
        the provided arrays. Both arrays must have exactly @n_properties elements,
        and the names and values correspond by index.
        
        Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY)
        which are not explicitly specified are set to their default values.
        @param object_type: the object type to instantiate
        @param n_properties: the number of properties
        @param names: the names of each property to be set
        @param values: the values of each property to be set
        @type object_type: GType
        @type n_properties: int
        @returns: Newly created Object
        @rtype: Object
        """
        return object
    @staticmethod
    def newv(object_type=None, n_parameters=None, parameters=None):
        """        Creates a new instance of a #GObject subtype and sets its properties.
        
        Construction parameters (see #G_PARAM_CONSTRUCT, #G_PARAM_CONSTRUCT_ONLY)
        which are not explicitly specified are set to their default values.
        @param object_type: the type id of the #GObject subtype to instantiate
        @param n_parameters: the length of the @parameters array
        @param parameters: an array of #GParameter
        @type object_type: GType
        @type n_parameters: int
        @returns: Newly created Object
        @rtype: Object
        """
        return object
    @staticmethod
    def compat_control(what=None, data=None):
        """        
        @type what: gsize
        @type data: gpointer
        @returns: 
        @rtype: gsize
        """
        return object
    @staticmethod
    def interface_find_property(g_iface=None, property_name=None):
        """        Find the #GParamSpec with the given name for an
        interface. Generally, the interface vtable passed in as @g_iface
        will be the default vtable from g_type_default_interface_ref(), or,
        if you know the interface has already been loaded,
        g_type_default_interface_peek().
        @param g_iface: any interface vtable for the  interface, or the default vtable for the interface
        @param property_name: name of a property to lookup.
        @type g_iface: TypeInterface
        @type property_name: str
        @returns: the #GParamSpec for the property of the
          interface with the name @property_name, or %NULL if no
          such property exists.
        @rtype: ParamSpec
        """
        return object
    @staticmethod
    def interface_install_property(g_iface=None, pspec=None):
        """        Add a property to an interface; this is only useful for interfaces
        that are added to GObject-derived types. Adding a property to an
        interface forces all objects classes with that interface to have a
        compatible property. The compatible property could be a newly
        created #GParamSpec, but normally
        g_object_class_override_property() will be used so that the object
        class only needs to provide an implementation and inherits the
        property description, default value, bounds, and so forth from the
        interface property.
        
        This function is meant to be called from the interface's default
        vtable initialization function (the @class_init member of
        #GTypeInfo.) It must not be called after after @class_init has
        been called for any object types implementing this interface.
        
        If @pspec is a floating reference, it will be consumed.
        @param g_iface: any interface vtable for the    interface, or the default  vtable for the interface.
        @param pspec: the #GParamSpec for the new property
        @type g_iface: TypeInterface
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def interface_list_properties(g_iface=None, n_properties_p=None):
        """        Lists the properties of an interface.Generally, the interface
        vtable passed in as @g_iface will be the default vtable from
        g_type_default_interface_ref(), or, if you know the interface has
        already been loaded, g_type_default_interface_peek().
        @param g_iface: any interface vtable for the  interface, or the default vtable for the interface
        @param n_properties_p: location to store number of properties returned.
        @type g_iface: TypeInterface
        @type n_properties_p: int
        @rtype: None
        """
        return object
    
    def constructed(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def dispatch_properties_changed(self, n_pspecs=None, pspecs=None):
        """        
        @type n_pspecs: int
        @type pspecs: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def dispose(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def finalize(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def get_property(self, property_id=None, value=None, pspec=None):
        """        
        @type property_id: int
        @type value: Value
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def notify(self, pspec=None):
        """        Emits a "notify" signal for the property @property_name on @object.
        
        When possible, eg. when signaling a property change from within the class
        that registered the property, you should use g_object_notify_by_pspec()
        instead.
        
        Note that emission of the notify signal may be blocked with
        g_object_freeze_notify(). In this case, the signal emissions are queued
        and will be emitted (in reverse order) when g_object_thaw_notify() is
        called.
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def set_property(self, property_id=None, value=None, pspec=None):
        """        
        @type property_id: int
        @type value: Value
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def add_toggle_ref(self, notify=None, data=None):
        """        Increases the reference count of the object by one and sets a
        callback to be called when all other references to the object are
        dropped, or when this is already the last reference to the object
        and another reference is established.
        
        This functionality is intended for binding @object to a proxy
        object managed by another memory manager. This is done with two
        paired references: the strong reference added by
        g_object_add_toggle_ref() and a reverse reference to the proxy
        object which is either a strong reference or weak reference.
        
        The setup is that when there are no other references to @object,
        only a weak reference is held in the reverse direction from @object
        to the proxy object, but when there are other references held to
        @object, a strong reference is held. The @notify callback is called
        when the reference from @object to the proxy object should be
        "toggled" from strong to weak (@is_last_ref true) or weak to strong
        (@is_last_ref false).
        
        Since a (normal) reference must be held to the object before
        calling g_object_add_toggle_ref(), the initial state of the reverse
        link is always strong.
        
        Multiple toggle references may be added to the same gobject,
        however if there are multiple toggle references to an object, none
        of them will ever be notified until all but one are removed.  For
        this reason, you should only ever use a toggle reference if there
        is important state in the proxy object.
        @param notify: a function to call when this reference is the  last reference to the object, or is no longer  the last reference.
        @param data: data to pass to @notify
        @type notify: ToggleNotify
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def add_weak_pointer(self, weak_pointer_location=None):
        """        Adds a weak reference from weak_pointer to @object to indicate that
        the pointer located at @weak_pointer_location is only valid during
        the lifetime of @object. When the @object is finalized,
        @weak_pointer will be set to %NULL.
        
        Note that as with g_object_weak_ref(), the weak references created by
        this method are not thread-safe: they cannot safely be used in one
        thread if the object's last g_object_unref() might happen in another
        thread. Use #GWeakRef if thread-safety is required.
        @param weak_pointer_location: The memory address    of a pointer.
        @type weak_pointer_location: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def bind_property(self, source_property=None, target=None, target_property=None, flags=None):
        """        Creates a binding between @source_property on @source and @target_property
        on @target. Whenever the @source_property is changed the @target_property is
        updated using the same value. For instance:
        
        |[
          g_object_bind_property (action, "active", widget, "sensitive", 0);
        ]|
        
        Will result in the "sensitive" property of the widget #GObject instance to be
        updated with the same value of the "active" property of the action #GObject
        instance.
        
        If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
        if @target_property on @target changes then the @source_property on @source
        will be updated as well.
        
        The binding will automatically be removed when either the @source or the
        @target instances are finalized. To remove the binding without affecting the
        @source and the @target you can just call g_object_unref() on the returned
        #GBinding instance.
        
        A #GObject can have multiple bindings.
        @param source_property: the property on @source to bind
        @param target: the target #GObject
        @param target_property: the property on @target to bind
        @param flags: flags to pass to #GBinding
        @type source_property: str
        @type target: Object
        @type target_property: str
        @type flags: BindingFlags
        @returns: the #GBinding instance representing the
     binding between the two #GObject instances. The binding is released
     whenever the #GBinding reference count reaches zero.
        @rtype: Binding
        """
        return object
    
    def bind_property_full(self, source_property=None, target=None, target_property=None, flags=None, transform_to=None, transform_from=None, user_data=None, notify=None):
        """        Complete version of g_object_bind_property().
        
        Creates a binding between @source_property on @source and @target_property
        on @target, allowing you to set the transformation functions to be used by
        the binding.
        
        If @flags contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
        if @target_property on @target changes then the @source_property on @source
        will be updated as well. The @transform_from function is only used in case
        of bidirectional bindings, otherwise it will be ignored
        
        The binding will automatically be removed when either the @source or the
        @target instances are finalized. To remove the binding without affecting the
        @source and the @target you can just call g_object_unref() on the returned
        #GBinding instance.
        
        A #GObject can have multiple bindings.
        
        The same @user_data parameter will be used for both @transform_to
        and @transform_from transformation functions; the @notify function will
        be called once, when the binding is removed. If you need different data
        for each transformation function, please use
        g_object_bind_property_with_closures() instead.
        @param source_property: the property on @source to bind
        @param target: the target #GObject
        @param target_property: the property on @target to bind
        @param flags: flags to pass to #GBinding
        @param transform_to: the transformation function     from the @source to the @target, or %NULL to use the default
        @param transform_from: the transformation function     from the @target to the @source, or %NULL to use the default
        @param user_data: custom data to be passed to the transformation functions,     or %NULL
        @param notify: a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
        @type source_property: str
        @type target: Object
        @type target_property: str
        @type flags: BindingFlags
        @type transform_to: BindingTransformFunc
        @type transform_from: BindingTransformFunc
        @type user_data: gpointer
        @type notify: GLib.DestroyNotify
        @returns: the #GBinding instance representing the
     binding between the two #GObject instances. The binding is released
     whenever the #GBinding reference count reaches zero.
        @rtype: Binding
        """
        return object
    
    def bind_property_with_closures(self, source_property=None, target=None, target_property=None, flags=None, transform_to=None, transform_from=None):
        """        Creates a binding between @source_property on @source and @target_property
        on @target, allowing you to set the transformation functions to be used by
        the binding.
        
        This function is the language bindings friendly version of
        g_object_bind_property_full(), using #GClosures instead of
        function pointers.
        @param source_property: the property on @source to bind
        @param target: the target #GObject
        @param target_property: the property on @target to bind
        @param flags: flags to pass to #GBinding
        @param transform_to: a #GClosure wrapping the transformation function     from the @source to the @target, or %NULL to use the default
        @param transform_from: a #GClosure wrapping the transformation function     from the @target to the @source, or %NULL to use the default
        @type source_property: str
        @type target: Object
        @type target_property: str
        @type flags: BindingFlags
        @type transform_to: Closure
        @type transform_from: Closure
        @returns: the #GBinding instance representing the
     binding between the two #GObject instances. The binding is released
     whenever the #GBinding reference count reaches zero.
        @rtype: Binding
        """
        return object
    
    def connect(self, signal_spec=None, *args):
        """        A convenience function to connect multiple signals at once.
        
        The signal specs expected by this function have the form
        "modifier::signal_name", where modifier can be one of the following:
        * - signal: equivalent to g_signal_connect_data (..., NULL, 0)
        - object-signal, object_signal: equivalent to g_signal_connect_object (..., 0)
        - swapped-signal, swapped_signal: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED)
        - swapped_object_signal, swapped-object-signal: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED)
        - signal_after, signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_AFTER)
        - object_signal_after, object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_AFTER)
        - swapped_signal_after, swapped-signal-after: equivalent to g_signal_connect_data (..., NULL, G_CONNECT_SWAPPED | G_CONNECT_AFTER)
        - swapped_object_signal_after, swapped-object-signal-after: equivalent to g_signal_connect_object (..., G_CONNECT_SWAPPED | G_CONNECT_AFTER)
        
        |[<!-- language="C" -->
          menu->toplevel = g_object_connect (g_object_new (GTK_TYPE_WINDOW,
        						   "type", GTK_WINDOW_POPUP,
        						   "child", menu,
        						   NULL),
        				     "signal::event", gtk_menu_window_event, menu,
        				     "signal::size_request", gtk_menu_window_size_request, menu,
        				     "signal::destroy", gtk_widget_destroyed, &menu->toplevel,
        				     NULL);
        ]|
        @param signal_spec: the spec for the first signal
        @param *args: #GCallback for the first signal, followed by data for the       first signal, followed optionally by more signal       spec/callback/data triples, followed by %NULL
        @type signal_spec: str
        @returns: @object
        @rtype: Object
        """
        return object
    
    def disconnect(self, signal_spec=None, *args):
        """        A convenience function to disconnect multiple signals at once.
        
        The signal specs expected by this function have the form
        "any_signal", which means to disconnect any signal with matching
        callback and data, or "any_signal::signal_name", which only
        disconnects the signal named "signal_name".
        @param signal_spec: the spec for the first signal
        @param *args: #GCallback for the first signal, followed by data for the first signal,  followed optionally by more signal spec/callback/data triples,  followed by %NULL
        @type signal_spec: str
        @returns: 
        @rtype: None
        """
        return object
    
    def dup_data(self, key=None, dup_func=None, user_data=None):
        """        This is a variant of g_object_get_data() which returns
        a 'duplicate' of the value. @dup_func defines the
        meaning of 'duplicate' in this context, it could e.g.
        take a reference on a ref-counted object.
        
        If the @key is not set on the object then @dup_func
        will be called with a %NULL argument.
        
        Note that @dup_func is called while user data of @object
        is locked.
        
        This function can be useful to avoid races when multiple
        threads are using object data on the same key on the same
        object.
        @param key: a string, naming the user data pointer
        @param dup_func: function to dup the value
        @param user_data: passed as user_data to @dup_func
        @type key: str
        @type dup_func: GLib.DuplicateFunc
        @type user_data: gpointer
        @returns: the result of calling @dup_func on the value
     associated with @key on @object, or %NULL if not set.
     If @dup_func is %NULL, the value is returned
     unmodified.
        @rtype: gpointer
        """
        return object
    
    def dup_qdata(self, quark=None, dup_func=None, user_data=None):
        """        This is a variant of g_object_get_qdata() which returns
        a 'duplicate' of the value. @dup_func defines the
        meaning of 'duplicate' in this context, it could e.g.
        take a reference on a ref-counted object.
        
        If the @quark is not set on the object then @dup_func
        will be called with a %NULL argument.
        
        Note that @dup_func is called while user data of @object
        is locked.
        
        This function can be useful to avoid races when multiple
        threads are using object data on the same key on the same
        object.
        @param quark: a #GQuark, naming the user data pointer
        @param dup_func: function to dup the value
        @param user_data: passed as user_data to @dup_func
        @type quark: GLib.Quark
        @type dup_func: GLib.DuplicateFunc
        @type user_data: gpointer
        @returns: the result of calling @dup_func on the value
     associated with @quark on @object, or %NULL if not set.
     If @dup_func is %NULL, the value is returned
     unmodified.
        @rtype: gpointer
        """
        return object
    
    def force_floating(self):
        """        This function is intended for #GObject implementations to re-enforce
        a [floating][floating-ref] object reference. Doing this is seldom
        required: all #GInitiallyUnowneds are created with a floating reference
        which usually just needs to be sunken by calling g_object_ref_sink().
        @returns: 
        @rtype: None
        """
        return object
    
    def freeze_notify(self):
        """        Increases the freeze count on @object. If the freeze count is
        non-zero, the emission of "notify" signals on @object is
        stopped. The signals are queued until the freeze count is decreased
        to zero. Duplicate notifications are squashed so that at most one
        #GObject::notify signal is emitted for each property modified while the
        object is frozen.
        
        This is necessary for accessors that modify multiple properties to prevent
        premature notification while the object is still being modified.
        @returns: 
        @rtype: None
        """
        return object
    
    def get(self, first_property_name=None, *args):
        """        Gets properties of an object.
        
        In general, a copy is made of the property contents and the caller
        is responsible for freeing the memory in the appropriate manner for
        the type, for instance by calling g_free() or g_object_unref().
        
        Here is an example of using g_object_get() to get the contents
        of three properties: an integer, a string and an object:
        |[<!-- language="C" -->
         gint intval;
         gchar *strval;
         GObject *objval;
        
         g_object_get (my_object,
                       "int-property", &intval,
                       "str-property", &strval,
                       "obj-property", &objval,
                       NULL);
        
         // Do something with intval, strval, objval
        
         g_free (strval);
         g_object_unref (objval);
         ]|
        @param first_property_name: name of the first property to get
        @param *args: return location for the first property, followed optionally by more  name/return location pairs, followed by %NULL
        @type first_property_name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def get_data(self, key=None):
        """        Gets a named field from the objects table of associations (see g_object_set_data()).
        @param key: name of the key for that association
        @type key: str
        @returns: the data if found,
          or %NULL if no such data exists.
        @rtype: gpointer
        """
        return object
    
    def get_property(self, property_name=None, value=None):
        """        Gets a property of an object. @value must have been initialized to the
        expected type of the property (or a type to which the expected type can be
        transformed) using g_value_init().
        
        In general, a copy is made of the property contents and the caller is
        responsible for freeing the memory by calling g_value_unset().
        
        Note that g_object_get_property() is really intended for language
        bindings, g_object_get() is much more convenient for C programming.
        @param property_name: the name of the property to get
        @param value: return location for the property value
        @type property_name: str
        @type value: Value
        @returns: 
        @rtype: None
        """
        return object
    
    def get_qdata(self, quark=None):
        """        This function gets back user data pointers stored via
        g_object_set_qdata().
        @param quark: A #GQuark, naming the user data pointer
        @type quark: GLib.Quark
        @returns: The user data pointer set, or %NULL
        @rtype: gpointer
        """
        return object
    
    def get_valist(self, first_property_name=None, var_args=None):
        """        Gets properties of an object.
        
        In general, a copy is made of the property contents and the caller
        is responsible for freeing the memory in the appropriate manner for
        the type, for instance by calling g_free() or g_object_unref().
        
        See g_object_get().
        @param first_property_name: name of the first property to get
        @param var_args: return location for the first property, followed optionally by more  name/return location pairs, followed by %NULL
        @type first_property_name: str
        @type var_args: va_list
        @returns: 
        @rtype: None
        """
        return object
    
    def getv(self, n_properties=None, names=None, values=None):
        """        Gets @n_properties properties for an @object.
        Obtained properties will be set to @values. All properties must be valid.
        Warnings will be emitted and undefined behaviour may result if invalid
        properties are passed in.
        @param n_properties: the number of properties
        @param names: the names of each property to get
        @param values: the values of each property to get
        @type n_properties: int
        @returns: 
        @rtype: None
        """
        return object
    
    def is_floating(self):
        """        Checks whether @object has a [floating][floating-ref] reference.
        @returns: %TRUE if @object has a floating reference
        @rtype: bool
        """
        return object
    
    def notify(self, property_name=None):
        """        Emits a "notify" signal for the property @property_name on @object.
        
        When possible, eg. when signaling a property change from within the class
        that registered the property, you should use g_object_notify_by_pspec()
        instead.
        
        Note that emission of the notify signal may be blocked with
        g_object_freeze_notify(). In this case, the signal emissions are queued
        and will be emitted (in reverse order) when g_object_thaw_notify() is
        called.
        @param property_name: the name of a property installed on the class of @object.
        @type property_name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def notify_by_pspec(self, pspec=None):
        """        Emits a "notify" signal for the property specified by @pspec on @object.
        
        This function omits the property name lookup, hence it is faster than
        g_object_notify().
        
        One way to avoid using g_object_notify() from within the
        class that registered the properties, and using g_object_notify_by_pspec()
        instead, is to store the GParamSpec used with
        g_object_class_install_property() inside a static array, e.g.:
        
        |[<!-- language="C" -->
          enum
          {
            PROP_0,
            PROP_FOO,
            PROP_LAST
          };
        
          static GParamSpec *properties[PROP_LAST];
        
          static void
          my_object_class_init (MyObjectClass *klass)
          {
            properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
                                                     0, 100,
                                                     50,
                                                     G_PARAM_READWRITE);
            g_object_class_install_property (gobject_class,
                                             PROP_FOO,
                                             properties[PROP_FOO]);
          }
        ]|
        
        and then notify a change on the "foo" property with:
        
        |[<!-- language="C" -->
          g_object_notify_by_pspec (self, properties[PROP_FOO]);
        ]|
        @param pspec: the #GParamSpec of a property installed on the class of @object.
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def ref(self):
        """        Increases the reference count of @object.
        
        Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
        of @object will be propagated to the return type (using the GCC typeof()
        extension), so any casting the caller needs to do on the return type must be
        explicit.
        @returns: the same @object
        @rtype: Object
        """
        return object
    
    def ref_sink(self):
        """        Increase the reference count of @object, and possibly remove the
        [floating][floating-ref] reference, if @object has a floating reference.
        
        In other words, if the object is floating, then this call "assumes
        ownership" of the floating reference, converting it to a normal
        reference by clearing the floating flag while leaving the reference
        count unchanged.  If the object is not floating, then this call
        adds a new normal reference increasing the reference count by one.
        
        Since GLib 2.56, the type of @object will be propagated to the return type
        under the same conditions as for g_object_ref().
        @returns: @object
        @rtype: Object
        """
        return object
    
    def remove_toggle_ref(self, notify=None, data=None):
        """        Removes a reference added with g_object_add_toggle_ref(). The
        reference count of the object is decreased by one.
        @param notify: a function to call when this reference is the  last reference to the object, or is no longer  the last reference.
        @param data: data to pass to @notify
        @type notify: ToggleNotify
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def remove_weak_pointer(self, weak_pointer_location=None):
        """        Removes a weak reference from @object that was previously added
        using g_object_add_weak_pointer(). The @weak_pointer_location has
        to match the one used with g_object_add_weak_pointer().
        @param weak_pointer_location: The memory address    of a pointer.
        @type weak_pointer_location: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def replace_data(self, key=None, oldval=None, newval=None, destroy=None, old_destroy=None):
        """        Compares the user data for the key @key on @object with
        @oldval, and if they are the same, replaces @oldval with
        @newval.
        
        This is like a typical atomic compare-and-exchange
        operation, for user data on an object.
        
        If the previous value was replaced then ownership of the
        old value (@oldval) is passed to the caller, including
        the registered destroy notify for it (passed out in @old_destroy).
        It’s up to the caller to free this as needed, which may
        or may not include using @old_destroy as sometimes replacement
        should not destroy the object in the normal way.
        @param key: a string, naming the user data pointer
        @param oldval: the old value to compare against
        @param newval: the new value
        @param destroy: a destroy notify for the new value
        @param old_destroy: destroy notify for the existing value
        @type key: str
        @type oldval: gpointer
        @type newval: gpointer
        @type destroy: GLib.DestroyNotify
        @type old_destroy: GLib.DestroyNotify
        @returns: %TRUE if the existing value for @key was replaced  by @newval, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def replace_qdata(self, quark=None, oldval=None, newval=None, destroy=None, old_destroy=None):
        """        Compares the user data for the key @quark on @object with
        @oldval, and if they are the same, replaces @oldval with
        @newval.
        
        This is like a typical atomic compare-and-exchange
        operation, for user data on an object.
        
        If the previous value was replaced then ownership of the
        old value (@oldval) is passed to the caller, including
        the registered destroy notify for it (passed out in @old_destroy).
        It’s up to the caller to free this as needed, which may
        or may not include using @old_destroy as sometimes replacement
        should not destroy the object in the normal way.
        @param quark: a #GQuark, naming the user data pointer
        @param oldval: the old value to compare against
        @param newval: the new value
        @param destroy: a destroy notify for the new value
        @param old_destroy: destroy notify for the existing value
        @type quark: GLib.Quark
        @type oldval: gpointer
        @type newval: gpointer
        @type destroy: GLib.DestroyNotify
        @type old_destroy: GLib.DestroyNotify
        @returns: %TRUE if the existing value for @quark was replaced  by @newval, %FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def run_dispose(self):
        """        Releases all references to other objects. This can be used to break
        reference cycles.
        
        This function should only be called from object system implementations.
        @returns: 
        @rtype: None
        """
        return object
    
    def set(self, first_property_name=None, *args):
        """        Sets properties on an object.
        
        Note that the "notify" signals are queued and only emitted (in
        reverse order) after all properties have been set. See
        g_object_freeze_notify().
        @param first_property_name: name of the first property to set
        @param *args: value for the first property, followed optionally by more  name/value pairs, followed by %NULL
        @type first_property_name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_data(self, key=None, data=None):
        """        Each object carries around a table of associations from
        strings to pointers.  This function lets you set an association.
        
        If the object already had an association with that name,
        the old association will be destroyed.
        @param key: name of the key
        @param data: data to associate with that key
        @type key: str
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_data_full(self, key=None, data=None, destroy=None):
        """        Like g_object_set_data() except it adds notification
        for when the association is destroyed, either by setting it
        to a different value or when the object is destroyed.
        
        Note that the @destroy callback is not called if @data is %NULL.
        @param key: name of the key
        @param data: data to associate with that key
        @param destroy: function to call when the association is destroyed
        @type key: str
        @type data: gpointer
        @type destroy: GLib.DestroyNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def set_property(self, property_name=None, value=None):
        """        Sets a property on an object.
        @param property_name: the name of the property to set
        @param value: the value
        @type property_name: str
        @type value: Value
        @returns: 
        @rtype: None
        """
        return object
    
    def set_qdata(self, quark=None, data=None):
        """        This sets an opaque, named pointer on an object.
        The name is specified through a #GQuark (retrived e.g. via
        g_quark_from_static_string()), and the pointer
        can be gotten back from the @object with g_object_get_qdata()
        until the @object is finalized.
        Setting a previously set user data pointer, overrides (frees)
        the old pointer set, using #NULL as pointer essentially
        removes the data stored.
        @param quark: A #GQuark, naming the user data pointer
        @param data: An opaque user data pointer
        @type quark: GLib.Quark
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_qdata_full(self, quark=None, data=None, destroy=None):
        """        This function works like g_object_set_qdata(), but in addition,
        a void (*destroy) (gpointer) function may be specified which is
        called with @data as argument when the @object is finalized, or
        the data is being overwritten by a call to g_object_set_qdata()
        with the same @quark.
        @param quark: A #GQuark, naming the user data pointer
        @param data: An opaque user data pointer
        @param destroy: Function to invoke with @data as argument, when @data           needs to be freed
        @type quark: GLib.Quark
        @type data: gpointer
        @type destroy: GLib.DestroyNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def set_valist(self, first_property_name=None, var_args=None):
        """        Sets properties on an object.
        @param first_property_name: name of the first property to set
        @param var_args: value for the first property, followed optionally by more  name/value pairs, followed by %NULL
        @type first_property_name: str
        @type var_args: va_list
        @returns: 
        @rtype: None
        """
        return object
    
    def setv(self, n_properties=None, names=None, values=None):
        """        Sets @n_properties properties for an @object.
        Properties to be set will be taken from @values. All properties must be
        valid. Warnings will be emitted and undefined behaviour may result if invalid
        properties are passed in.
        @param n_properties: the number of properties
        @param names: the names of each property to be set
        @param values: the values of each property to be set
        @type n_properties: int
        @returns: 
        @rtype: None
        """
        return object
    
    def steal_data(self, key=None):
        """        Remove a specified datum from the object's data associations,
        without invoking the association's destroy handler.
        @param key: name of the key
        @type key: str
        @returns: the data if found, or %NULL
          if no such data exists.
        @rtype: gpointer
        """
        return object
    
    def steal_qdata(self, quark=None):
        """        This function gets back user data pointers stored via
        g_object_set_qdata() and removes the @data from object
        without invoking its destroy() function (if any was
        set).
        Usually, calling this function is only required to update
        user data pointers with a destroy notifier, for example:
        |[<!-- language="C" -->
        void
        object_add_to_user_list (GObject     *object,
                                 const gchar *new_string)
        {
          // the quark, naming the object data
          GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
          // retrive the old string list
          GList *list = g_object_steal_qdata (object, quark_string_list);
        
          // prepend new string
          list = g_list_prepend (list, g_strdup (new_string));
          // this changed 'list', so we need to set it again
          g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
        }
        static void
        free_string_list (gpointer data)
        {
          GList *node, *list = data;
        
          for (node = list; node; node = node->next)
            g_free (node->data);
          g_list_free (list);
        }
        ]|
        Using g_object_get_qdata() in the above example, instead of
        g_object_steal_qdata() would have left the destroy function set,
        and thus the partial string list would have been freed upon
        g_object_set_qdata_full().
        @param quark: A #GQuark, naming the user data pointer
        @type quark: GLib.Quark
        @returns: The user data pointer set, or %NULL
        @rtype: gpointer
        """
        return object
    
    def thaw_notify(self):
        """        Reverts the effect of a previous call to
        g_object_freeze_notify(). The freeze count is decreased on @object
        and when it reaches zero, queued "notify" signals are emitted.
        
        Duplicate notifications for each property are squashed so that at most one
        #GObject::notify signal is emitted for each property, in the reverse order
        in which they have been queued.
        
        It is an error to call this function when the freeze count is zero.
        @returns: 
        @rtype: None
        """
        return object
    
    def unref(self):
        """        Decreases the reference count of @object. When its reference count
        drops to 0, the object is finalized (i.e. its memory is freed).
        
        If the pointer to the #GObject may be reused in future (for example, if it is
        an instance variable of another object), it is recommended to clear the
        pointer to %NULL rather than retain a dangling pointer to a potentially
        invalid #GObject instance. Use g_clear_object() for this.
        @returns: 
        @rtype: None
        """
        return object
    
    def watch_closure(self, closure=None):
        """        This function essentially limits the life time of the @closure to
        the life time of the object. That is, when the object is finalized,
        the @closure is invalidated by calling g_closure_invalidate() on
        it, in order to prevent invocations of the closure with a finalized
        (nonexisting) object. Also, g_object_ref() and g_object_unref() are
        added as marshal guards to the @closure, to ensure that an extra
        reference count is held on @object during invocation of the
        @closure.  Usually, this function will be called on closures that
        use this @object as closure data.
        @param closure: GClosure to watch
        @type closure: Closure
        @returns: 
        @rtype: None
        """
        return object
    
    def weak_ref(self, notify=None, data=None):
        """        Adds a weak reference callback to an object. Weak references are
        used for notification when an object is finalized. They are called
        "weak references" because they allow you to safely hold a pointer
        to an object without calling g_object_ref() (g_object_ref() adds a
        strong reference, that is, forces the object to stay alive).
        
        Note that the weak references created by this method are not
        thread-safe: they cannot safely be used in one thread if the
        object's last g_object_unref() might happen in another thread.
        Use #GWeakRef if thread-safety is required.
        @param notify: callback to invoke before the object is freed
        @param data: extra data to pass to notify
        @type notify: WeakNotify
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def weak_unref(self, notify=None, data=None):
        """        Removes a weak reference callback to an object.
        @param notify: callback to search for
        @param data: data to search for
        @type notify: WeakNotify
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object

    @property
    def g_type_instance(self):
        return object

    @property
    def ref_count(self):
        return object

    @property
    def qdata(self):
        return object


class ObjectClass():
    """The class structure for the GObject type.

|[<!-- language="C" -->
// Example of implementing a singleton using a constructor.
static MySingleton *the_singleton = NULL;

static GObject*
my_singleton_constructor (GType                  type,
                          guint                  n_construct_params,
                          GObjectConstructParam *construct_params)
{
  GObject *object;
  
  if (!the_singleton)
    {
      object = G_OBJECT_CLASS (parent_class)->constructor (type,
                                                           n_construct_params,
                                                           construct_params);
      the_singleton = MY_SINGLETON (object);
    }
  else
    object = g_object_ref (G_OBJECT (the_singleton));

  return object;
}
]|"""
    
    def find_property(self, property_name=None):
        """        Looks up the #GParamSpec for a property of a class.
        @param property_name: the name of the property to look up
        @type property_name: str
        @returns: the #GParamSpec for the property, or
          %NULL if the class doesn't have a property of that name
        @rtype: ParamSpec
        """
        return object
    
    def install_properties(self, n_pspecs=None, pspecs=None):
        """        Installs new properties from an array of #GParamSpecs.
        
        All properties should be installed during the class initializer.  It
        is possible to install properties after that, but doing so is not
        recommend, and specifically, is not guaranteed to be thread-safe vs.
        use of properties on the same type on other threads.
        
        The property id of each property is the index of each #GParamSpec in
        the @pspecs array.
        
        The property id of 0 is treated specially by #GObject and it should not
        be used to store a #GParamSpec.
        
        This function should be used if you plan to use a static array of
        #GParamSpecs and g_object_notify_by_pspec(). For instance, this
        class initialization:
        
        |[<!-- language="C" -->
        enum {
          PROP_0, PROP_FOO, PROP_BAR, N_PROPERTIES
        };
        
        static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
        
        static void
        my_object_class_init (MyObjectClass *klass)
        {
          GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
        
          obj_properties[PROP_FOO] =
            g_param_spec_int ("foo", "Foo", "Foo",
                              -1, G_MAXINT,
                              0,
                              G_PARAM_READWRITE);
        
          obj_properties[PROP_BAR] =
            g_param_spec_string ("bar", "Bar", "Bar",
                                 NULL,
                                 G_PARAM_READWRITE);
        
          gobject_class->set_property = my_object_set_property;
          gobject_class->get_property = my_object_get_property;
          g_object_class_install_properties (gobject_class,
                                             N_PROPERTIES,
                                             obj_properties);
        }
        ]|
        
        allows calling g_object_notify_by_pspec() to notify of property changes:
        
        |[<!-- language="C" -->
        void
        my_object_set_foo (MyObject *self, gint foo)
        {
          if (self->foo != foo)
            {
              self->foo = foo;
              g_object_notify_by_pspec (G_OBJECT (self), obj_properties[PROP_FOO]);
            }
         }
        ]|
        @param n_pspecs: the length of the #GParamSpecs array
        @param pspecs: the #GParamSpecs array   defining the new properties
        @type n_pspecs: int
        @returns: 
        @rtype: None
        """
        return object
    
    def install_property(self, property_id=None, pspec=None):
        """        Installs a new property.
        
        All properties should be installed during the class initializer.  It
        is possible to install properties after that, but doing so is not
        recommend, and specifically, is not guaranteed to be thread-safe vs.
        use of properties on the same type on other threads.
        
        Note that it is possible to redefine a property in a derived class,
        by installing a property with the same name. This can be useful at times,
        e.g. to change the range of allowed values or the default value.
        @param property_id: the id for the new property
        @param pspec: the #GParamSpec for the new property
        @type property_id: int
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def list_properties(self, n_properties=None):
        """        Get an array of #GParamSpec* for all properties of a class.
        @param n_properties: return location for the length of the returned array
        @type n_properties: int
        @rtype: None
        """
        return object
    
    def override_property(self, property_id=None, name=None):
        """        Registers @property_id as referring to a property with the name
        @name in a parent class or in an interface implemented by @oclass.
        This allows this class to "override" a property implementation in
        a parent class or to provide the implementation of a property from
        an interface.
        
        Internally, overriding is implemented by creating a property of type
        #GParamSpecOverride; generally operations that query the properties of
        the object class, such as g_object_class_find_property() or
        g_object_class_list_properties() will return the overridden
        property. However, in one case, the @construct_properties argument of
        the @constructor virtual function, the #GParamSpecOverride is passed
        instead, so that the @param_id field of the #GParamSpec will be
        correct.  For virtually all uses, this makes no difference. If you
        need to get the overridden property, you can call
        g_param_spec_get_redirect_target().
        @param property_id: the new property ID
        @param name: the name of a property registered in a parent class or  in an interface of this class.
        @type property_id: int
        @type name: str
        @returns: 
        @rtype: None
        """
        return object

    @property
    def g_type_class(self):
        return object

    @property
    def construct_properties(self):
        return object

    @property
    def constructor(self):
        return object

    @property
    def set_property(self):
        return object

    @property
    def get_property(self):
        return object

    @property
    def dispose(self):
        return object

    @property
    def finalize(self):
        return object

    @property
    def dispatch_properties_changed(self):
        return object

    @property
    def notify(self):
        return object

    @property
    def constructed(self):
        return object

    @property
    def flags(self):
        return object

    @property
    def pdummy(self):
        return object


class ObjectConstructParam():
    """The GObjectConstructParam struct is an auxiliary
structure used to hand #GParamSpec/#GValue pairs to the @constructor of
a #GObjectClass."""

    @property
    def pspec(self):
        return object

    @property
    def value(self):
        return object


class ParamSpec():
    """#GParamSpec is an object structure that encapsulates the metadata
required to specify parameters, such as e.g. #GObject properties.

## Parameter names # {#canonical-parameter-names}

Parameter names need to start with a letter (a-z or A-Z).
Subsequent characters can be letters, numbers or a '-'.
All other characters are replaced by a '-' during construction.
The result of this replacement is called the canonical name of
the parameter."""
    @staticmethod
    def internal(param_type=None, name=None, nick=None, blurb=None, flags=None):
        """        Creates a new #GParamSpec instance.
        
        A property name consists of segments consisting of ASCII letters and
        digits, separated by either the '-' or '_' character. The first
        character of a property name must be a letter. Names which violate these
        rules lead to undefined behaviour.
        
        When creating and looking up a #GParamSpec, either separator can be
        used, but they cannot be mixed. Using '-' is considerably more
        efficient and in fact required when using property names as detail
        strings for signals.
        
        Beyond the name, #GParamSpecs have two more descriptive
        strings associated with them, the @nick, which should be suitable
        for use as a label for the property in a property editor, and the
        @blurb, which should be a somewhat longer description, suitable for
        e.g. a tooltip. The @nick and @blurb should ideally be localized.
        @param param_type: the #GType for the property; must be derived from #G_TYPE_PARAM
        @param name: the canonical name of the property
        @param nick: the nickname of the property
        @param blurb: a short description of the property
        @param flags: a combination of #GParamFlags
        @type param_type: GType
        @type name: str
        @type nick: str
        @type blurb: str
        @type flags: ParamFlags
        @returns: a newly allocated #GParamSpec instance
        @rtype: ParamSpec
        """
        return object
    
    def finalize(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def value_set_default(self, value=None):
        """        
        @type value: Value
        @returns: 
        @rtype: None
        """
        return object
    
    def value_validate(self, value=None):
        """        
        @type value: Value
        @returns: 
        @rtype: bool
        """
        return object
    
    def values_cmp(self, value1=None, value2=None):
        """        
        @type value1: Value
        @type value2: Value
        @returns: 
        @rtype: int
        """
        return object
    
    def get_blurb(self):
        """        Get the short description of a #GParamSpec.
        @returns: the short description of @pspec.
        @rtype: str
        """
        return object
    
    def get_default_value(self):
        """        Gets the default value of @pspec as a pointer to a #GValue.
        
        The #GValue will remain valid for the life of @pspec.
        @returns: a pointer to a #GValue which must not be modified
        @rtype: Value
        """
        return object
    
    def get_name(self):
        """        Get the name of a #GParamSpec.
        
        The name is always an "interned" string (as per g_intern_string()).
        This allows for pointer-value comparisons.
        @returns: the name of @pspec.
        @rtype: str
        """
        return object
    
    def get_name_quark(self):
        """        Gets the GQuark for the name.
        @returns: the GQuark for @pspec->name.
        @rtype: GLib.Quark
        """
        return object
    
    def get_nick(self):
        """        Get the nickname of a #GParamSpec.
        @returns: the nickname of @pspec.
        @rtype: str
        """
        return object
    
    def get_qdata(self, quark=None):
        """        Gets back user data pointers stored via g_param_spec_set_qdata().
        @param quark: a #GQuark, naming the user data pointer
        @type quark: GLib.Quark
        @returns: the user data pointer set, or %NULL
        @rtype: gpointer
        """
        return object
    
    def get_redirect_target(self):
        """        If the paramspec redirects operations to another paramspec,
        returns that paramspec. Redirect is used typically for
        providing a new implementation of a property in a derived
        type while preserving all the properties from the parent
        type. Redirection is established by creating a property
        of type #GParamSpecOverride. See g_object_class_override_property()
        for an example of the use of this capability.
        @returns: paramspec to which requests on this
          paramspec should be redirected, or %NULL if none.
        @rtype: ParamSpec
        """
        return object
    
    def ref(self):
        """        Increments the reference count of @pspec.
        @returns: the #GParamSpec that was passed into this function
        @rtype: ParamSpec
        """
        return object
    
    def ref_sink(self):
        """        Convenience function to ref and sink a #GParamSpec.
        @returns: the #GParamSpec that was passed into this function
        @rtype: ParamSpec
        """
        return object
    
    def set_qdata(self, quark=None, data=None):
        """        Sets an opaque, named pointer on a #GParamSpec. The name is
        specified through a #GQuark (retrieved e.g. via
        g_quark_from_static_string()), and the pointer can be gotten back
        from the @pspec with g_param_spec_get_qdata().  Setting a
        previously set user data pointer, overrides (frees) the old pointer
        set, using %NULL as pointer essentially removes the data stored.
        @param quark: a #GQuark, naming the user data pointer
        @param data: an opaque user data pointer
        @type quark: GLib.Quark
        @type data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_qdata_full(self, quark=None, data=None, destroy=None):
        """        This function works like g_param_spec_set_qdata(), but in addition,
        a `void (*destroy) (gpointer)` function may be
        specified which is called with @data as argument when the @pspec is
        finalized, or the data is being overwritten by a call to
        g_param_spec_set_qdata() with the same @quark.
        @param quark: a #GQuark, naming the user data pointer
        @param data: an opaque user data pointer
        @param destroy: function to invoke with @data as argument, when @data needs to  be freed
        @type quark: GLib.Quark
        @type data: gpointer
        @type destroy: GLib.DestroyNotify
        @returns: 
        @rtype: None
        """
        return object
    
    def sink(self):
        """        The initial reference count of a newly created #GParamSpec is 1,
        even though no one has explicitly called g_param_spec_ref() on it
        yet. So the initial reference count is flagged as "floating", until
        someone calls `g_param_spec_ref (pspec); g_param_spec_sink
        (pspec);` in sequence on it, taking over the initial
        reference count (thus ending up with a @pspec that has a reference
        count of 1 still, but is not flagged "floating" anymore).
        @returns: 
        @rtype: None
        """
        return object
    
    def steal_qdata(self, quark=None):
        """        Gets back user data pointers stored via g_param_spec_set_qdata()
        and removes the @data from @pspec without invoking its destroy()
        function (if any was set).  Usually, calling this function is only
        required to update user data pointers with a destroy notifier.
        @param quark: a #GQuark, naming the user data pointer
        @type quark: GLib.Quark
        @returns: the user data pointer set, or %NULL
        @rtype: gpointer
        """
        return object
    
    def unref(self):
        """        Decrements the reference count of a @pspec.
        @returns: 
        @rtype: None
        """
        return object

    @property
    def g_type_instance(self):
        return object

    @property
    def name(self):
        return object

    @property
    def flags(self):
        return object

    @property
    def value_type(self):
        return object

    @property
    def owner_type(self):
        return object

    @property
    def _nick(self):
        return object

    @property
    def _blurb(self):
        return object

    @property
    def qdata(self):
        return object

    @property
    def ref_count(self):
        return object

    @property
    def param_id(self):
        return object


class ParamSpecBoolean(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for boolean properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecBoxed(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for boxed properties."""

    @property
    def parent_instance(self):
        return object


class ParamSpecChar(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for character properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecClass():
    """The class structure for the GParamSpec type.
Normally, GParamSpec classes are filled by
g_param_type_register_static()."""

    @property
    def g_type_class(self):
        return object

    @property
    def value_type(self):
        return object

    @property
    def finalize(self):
        return object

    @property
    def value_set_default(self):
        return object

    @property
    def value_validate(self):
        return object

    @property
    def values_cmp(self):
        return object

    @property
    def dummy(self):
        return object


class ParamSpecDouble(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for double properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object

    @property
    def epsilon(self):
        return object


class ParamSpecEnum(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for enum
properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def enum_class(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecFlags(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for flags
properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def flags_class(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecFloat(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for float properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object

    @property
    def epsilon(self):
        return object


class ParamSpecGType(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for #GType properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def is_a_type(self):
        return object


class ParamSpecInt(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for integer properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecInt64(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for 64bit integer properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecLong(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for long integer properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecObject(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for object properties."""

    @property
    def parent_instance(self):
        return object


class ParamSpecOverride(ParamSpec):
    """This is a type of #GParamSpec type that simply redirects operations to
another paramspec.  All operations other than getting or
setting the value are redirected, including accessing the nick and
blurb, validating a value, and so forth. See
g_param_spec_get_redirect_target() for retrieving the overidden
property. #GParamSpecOverride is used in implementing
g_object_class_override_property(), and will not be directly useful
unless you are implementing a new base type similar to GObject."""

    @property
    def parent_instance(self):
        return object

    @property
    def overridden(self):
        return object


class ParamSpecParam(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM
properties."""

    @property
    def parent_instance(self):
        return object


class ParamSpecPointer(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for pointer properties."""

    @property
    def parent_instance(self):
        return object


class ParamSpecPool():
    """A #GParamSpecPool maintains a collection of #GParamSpecs which can be
quickly accessed by owner and name. The implementation of the #GObject property
system uses such a pool to store the #GParamSpecs of the properties all object
types."""
    
    def insert(self, pspec=None, owner_type=None):
        """        Inserts a #GParamSpec in the pool.
        @param pspec: the #GParamSpec to insert
        @param owner_type: a #GType identifying the owner of @pspec
        @type pspec: ParamSpec
        @type owner_type: GType
        @returns: 
        @rtype: None
        """
        return object
    
    def list(self, owner_type=None, n_pspecs_p=None):
        """        Gets an array of all #GParamSpecs owned by @owner_type in
        the pool.
        @param owner_type: the owner to look for
        @param n_pspecs_p: return location for the length of the returned array
        @type owner_type: GType
        @type n_pspecs_p: int
        @rtype: None
        """
        return object
    
    def list_owned(self, owner_type=None):
        """        Gets an #GList of all #GParamSpecs owned by @owner_type in
        the pool.
        @param owner_type: the owner to look for
        @type owner_type: GType
        @returns: a
          #GList of all #GParamSpecs owned by @owner_type in
          the pool#GParamSpecs.
        @rtype: GLib.List
        """
        return object
    
    def lookup(self, param_name=None, owner_type=None, walk_ancestors=None):
        """        Looks up a #GParamSpec in the pool.
        @param param_name: the name to look for
        @param owner_type: the owner to look for
        @param walk_ancestors: If %TRUE, also try to find a #GParamSpec with @param_name  owned by an ancestor of @owner_type.
        @type param_name: str
        @type owner_type: GType
        @type walk_ancestors: bool
        @returns: The found #GParamSpec, or %NULL if no matching #GParamSpec was found.
        @rtype: ParamSpec
        """
        return object
    
    def remove(self, pspec=None):
        """        Removes a #GParamSpec from the pool.
        @param pspec: the #GParamSpec to remove
        @type pspec: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def new(type_prefixing=None):
        """        Creates a new #GParamSpecPool.
        
        If @type_prefixing is %TRUE, lookups in the newly created pool will
        allow to specify the owner as a colon-separated prefix of the
        property name, like "GtkContainer:border-width". This feature is
        deprecated, so you should always set @type_prefixing to %FALSE.
        @param type_prefixing: Whether the pool will support type-prefixed property names.
        @type type_prefixing: bool
        @returns: a newly allocated #GParamSpecPool.
        @rtype: ParamSpecPool
        """
        return object


class ParamSpecString(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for string
properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def default_value(self):
        return object

    @property
    def cset_first(self):
        return object

    @property
    def cset_nth(self):
        return object

    @property
    def substitutor(self):
        return object

    @property
    def null_fold_if_empty(self):
        return object

    @property
    def ensure_non_null(self):
        return object


class ParamSpecTypeInfo():
    """This structure is used to provide the type system with the information
required to initialize and destruct (finalize) a parameter's class and
instances thereof.
The initialized structure is passed to the g_param_type_register_static()
The type system will perform a deep copy of this structure, so its memory
does not need to be persistent across invocation of
g_param_type_register_static()."""

    @property
    def instance_size(self):
        return object

    @property
    def n_preallocs(self):
        return object

    @property
    def instance_init(self):
        return object

    @property
    def value_type(self):
        return object

    @property
    def finalize(self):
        return object

    @property
    def value_set_default(self):
        return object

    @property
    def value_validate(self):
        return object

    @property
    def values_cmp(self):
        return object


class ParamSpecUChar(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for unsigned character properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecUInt(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for unsigned integer properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecUInt64(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecULong(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for unsigned long integer properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def minimum(self):
        return object

    @property
    def maximum(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecUnichar(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def default_value(self):
        return object


class ParamSpecValueArray(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for #GValueArray properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def element_spec(self):
        return object

    @property
    def fixed_n_elements(self):
        return object


class ParamSpecVariant(ParamSpec):
    """A #GParamSpec derived structure that contains the meta data for #GVariant properties."""

    @property
    def parent_instance(self):
        return object

    @property
    def type(self):
        return object

    @property
    def default_value(self):
        return object

    @property
    def padding(self):
        return object


class Parameter():
    """The GParameter struct is an auxiliary structure used
to hand parameter name/value pairs to g_object_newv()."""

    @property
    def name(self):
        return object

    @property
    def value(self):
        return object


class SignalInvocationHint():
    """The #GSignalInvocationHint structure is used to pass on additional information
to callbacks during a signal emission."""

    @property
    def signal_id(self):
        return object

    @property
    def detail(self):
        return object

    @property
    def run_type(self):
        return object


class SignalQuery():
    """A structure holding in-depth information for a specific signal. It is
filled in by the g_signal_query() function."""

    @property
    def signal_id(self):
        return object

    @property
    def signal_name(self):
        return object

    @property
    def itype(self):
        return object

    @property
    def signal_flags(self):
        return object

    @property
    def return_type(self):
        return object

    @property
    def n_params(self):
        return object

    @property
    def param_types(self):
        return object


class TypeClass():
    """An opaque structure used as the base of all classes."""
    
    def add_private(self, private_size=None):
        """        Registers a private structure for an instantiatable type.
        
        When an object is allocated, the private structures for
        the type and all of its parent types are allocated
        sequentially in the same memory block as the public
        structures, and are zero-filled.
        
        Note that the accumulated size of the private structures of
        a type and all its parent types cannot exceed 64 KiB.
        
        This function should be called in the type's class_init() function.
        The private structure can be retrieved using the
        G_TYPE_INSTANCE_GET_PRIVATE() macro.
        
        The following example shows attaching a private structure
        MyObjectPrivate to an object MyObject defined in the standard
        GObject fashion in the type's class_init() function.
        
        Note the use of a structure member "priv" to avoid the overhead
        of repeatedly calling MY_OBJECT_GET_PRIVATE().
        
        |[<!-- language="C" -->
        typedef struct _MyObject        MyObject;
        typedef struct _MyObjectPrivate MyObjectPrivate;
        
        struct _MyObject {
         GObject parent;
        
         MyObjectPrivate *priv;
        };
        
        struct _MyObjectPrivate {
          int some_field;
        };
        
        static void
        my_object_class_init (MyObjectClass *klass)
        {
          g_type_class_add_private (klass, sizeof (MyObjectPrivate));
        }
        
        static void
        my_object_init (MyObject *my_object)
        {
          my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
                                                         MY_TYPE_OBJECT,
                                                         MyObjectPrivate);
          // my_object->priv->some_field will be automatically initialised to 0
        }
        
        static int
        my_object_get_some_field (MyObject *my_object)
        {
          MyObjectPrivate *priv;
        
          g_return_val_if_fail (MY_IS_OBJECT (my_object), 0);
        
          priv = my_object->priv;
        
          return priv->some_field;
        }
        ]|
        @param private_size: size of private structure
        @type private_size: gsize
        @returns: 
        @rtype: None
        """
        return object
    
    def get_instance_private_offset(self):
        """        Gets the offset of the private data for instances of @g_class.
        
        This is how many bytes you should add to the instance pointer of a
        class in order to get the private data for the type represented by
        @g_class.
        
        You can only call this function after you have registered a private
        data area for @g_class using g_type_class_add_private().
        @returns: the offset, in bytes
        @rtype: int
        """
        return object
    
    def get_private(self, private_type=None):
        """        
        @type private_type: GType
        @returns: 
        @rtype: gpointer
        """
        return object
    
    def peek_parent(self):
        """        This is a convenience function often needed in class initializers.
        It returns the class structure of the immediate parent type of the
        class passed in.  Since derived classes hold a reference count on
        their parent classes as long as they are instantiated, the returned
        class will always exist.
        
        This function is essentially equivalent to:
        g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)))
        @returns: the parent class
     of @g_class
        @rtype: TypeClass
        """
        return object
    
    def unref(self):
        """        Decrements the reference count of the class structure being passed in.
        Once the last reference count of a class has been released, classes
        may be finalized by the type system, so further dereferencing of a
        class pointer after g_type_class_unref() are invalid.
        @returns: 
        @rtype: None
        """
        return object
    
    def unref_uncached(self):
        """        A variant of g_type_class_unref() for use in #GTypeClassCacheFunc
        implementations. It unreferences a class without consulting the chain
        of #GTypeClassCacheFuncs, avoiding the recursion which would occur
        otherwise.
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def adjust_private_offset(g_class=None, private_size_or_offset=None):
        """        
        @type g_class: gpointer
        @type private_size_or_offset: int
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def peek(type=None):
        """        This function is essentially the same as g_type_class_ref(),
        except that the classes reference count isn't incremented.
        As a consequence, this function may return %NULL if the class
        of the type passed in does not currently exist (hasn't been
        referenced before).
        @param type: type ID of a classed type
        @type type: GType
        @returns: the #GTypeClass
     structure for the given type ID or %NULL if the class does not
     currently exist
        @rtype: TypeClass
        """
        return object
    @staticmethod
    def peek_static(type=None):
        """        A more efficient version of g_type_class_peek() which works only for
        static types.
        @param type: type ID of a classed type
        @type type: GType
        @returns: the #GTypeClass
     structure for the given type ID or %NULL if the class does not
     currently exist or is dynamically loaded
        @rtype: TypeClass
        """
        return object
    @staticmethod
    def ref(type=None):
        """        Increments the reference count of the class structure belonging to
        @type. This function will demand-create the class if it doesn't
        exist already.
        @param type: type ID of a classed type
        @type type: GType
        @returns: the #GTypeClass
     structure for the given type ID
        @rtype: TypeClass
        """
        return object

    @property
    def g_type(self):
        return object


class TypeFundamentalInfo():
    """A structure that provides information to the type system which is
used specifically for managing fundamental types."""

    @property
    def type_flags(self):
        return object


class TypeInfo():
    """This structure is used to provide the type system with the information
required to initialize and destruct (finalize) a type's class and
its instances.

The initialized structure is passed to the g_type_register_static() function
(or is copied into the provided #GTypeInfo structure in the
g_type_plugin_complete_type_info()). The type system will perform a deep
copy of this structure, so its memory does not need to be persistent
across invocation of g_type_register_static()."""

    @property
    def class_size(self):
        return object

    @property
    def base_init(self):
        return object

    @property
    def base_finalize(self):
        return object

    @property
    def class_init(self):
        return object

    @property
    def class_finalize(self):
        return object

    @property
    def class_data(self):
        return object

    @property
    def instance_size(self):
        return object

    @property
    def n_preallocs(self):
        return object

    @property
    def instance_init(self):
        return object

    @property
    def value_table(self):
        return object


class TypeInstance():
    """An opaque structure used as the base of all type instances."""
    
    def get_private(self, private_type=None):
        """        
        @type private_type: GType
        @returns: 
        @rtype: gpointer
        """
        return object

    @property
    def g_class(self):
        return object


class TypeInterface():
    """An opaque structure used as the base of all interface types."""
    
    def peek_parent(self):
        """        Returns the corresponding #GTypeInterface structure of the parent type
        of the instance type to which @g_iface belongs. This is useful when
        deriving the implementation of an interface from the parent type and
        then possibly overriding some methods.
        @returns: the
     corresponding #GTypeInterface structure of the parent type of the
     instance type to which @g_iface belongs, or %NULL if the parent
     type doesn't conform to the interface
        @rtype: TypeInterface
        """
        return object
    @staticmethod
    def add_prerequisite(interface_type=None, prerequisite_type=None):
        """        Adds @prerequisite_type to the list of prerequisites of @interface_type.
        This means that any type implementing @interface_type must also implement
        @prerequisite_type. Prerequisites can be thought of as an alternative to
        interface derivation (which GType doesn't support). An interface can have
        at most one instantiatable prerequisite type.
        @param interface_type: #GType value of an interface type
        @param prerequisite_type: #GType value of an interface or instantiatable type
        @type interface_type: GType
        @type prerequisite_type: GType
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def get_plugin(instance_type=None, interface_type=None):
        """        Returns the #GTypePlugin structure for the dynamic interface
        @interface_type which has been added to @instance_type, or %NULL
        if @interface_type has not been added to @instance_type or does
        not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
        @param instance_type: #GType of an instantiatable type
        @param interface_type: #GType of an interface type
        @type instance_type: GType
        @type interface_type: GType
        @returns: the #GTypePlugin for the dynamic
     interface @interface_type of @instance_type
        @rtype: TypePlugin
        """
        return object
    @staticmethod
    def peek(instance_class=None, iface_type=None):
        """        Returns the #GTypeInterface structure of an interface to which the
        passed in class conforms.
        @param instance_class: a #GTypeClass structure
        @param iface_type: an interface ID which this class conforms to
        @type instance_class: TypeClass
        @type iface_type: GType
        @returns: the #GTypeInterface
     structure of @iface_type if implemented by @instance_class, %NULL
     otherwise
        @rtype: TypeInterface
        """
        return object
    @staticmethod
    def prerequisites(interface_type=None, n_prerequisites=None):
        """        Returns the prerequisites of an interfaces type.
        @param interface_type: an interface type
        @param n_prerequisites: location to return the number     of prerequisites, or %NULL
        @type interface_type: GType
        @type n_prerequisites: int
        @rtype: None
        """
        return object

    @property
    def g_type(self):
        return object

    @property
    def g_instance_type(self):
        return object


class TypeModuleClass():
    """In order to implement dynamic loading of types based on #GTypeModule,
the @load and @unload functions in #GTypeModuleClass must be implemented."""

    @property
    def parent_class(self):
        return object

    @property
    def load(self):
        return object

    @property
    def unload(self):
        return object

    @property
    def reserved1(self):
        return object

    @property
    def reserved2(self):
        return object

    @property
    def reserved3(self):
        return object

    @property
    def reserved4(self):
        return object


class TypePlugin():
    """The GObject type system supports dynamic loading of types.
The #GTypePlugin interface is used to handle the lifecycle
of dynamically loaded types. It goes as follows:

1. The type is initially introduced (usually upon loading the module
   the first time, or by your main application that knows what modules
   introduces what types), like this:
   |[<!-- language="C" -->
   new_type_id = g_type_register_dynamic (parent_type_id,
                                          "TypeName",
                                          new_type_plugin,
                                          type_flags);
   ]|
   where @new_type_plugin is an implementation of the
   #GTypePlugin interface.

2. The type's implementation is referenced, e.g. through
   g_type_class_ref() or through g_type_create_instance() (this is
   being called by g_object_new()) or through one of the above done on
   a type derived from @new_type_id.

3. This causes the type system to load the type's implementation by
   calling g_type_plugin_use() and g_type_plugin_complete_type_info()
   on @new_type_plugin.

4. At some point the type's implementation isn't required anymore,
   e.g. after g_type_class_unref() or g_type_free_instance() (called
   when the reference count of an instance drops to zero).

5. This causes the type system to throw away the information retrieved
   from g_type_plugin_complete_type_info() and then it calls
   g_type_plugin_unuse() on @new_type_plugin.

6. Things may repeat from the second step.

So basically, you need to implement a #GTypePlugin type that
carries a use_count, once use_count goes from zero to one, you need
to load the implementation to successfully handle the upcoming
g_type_plugin_complete_type_info() call. Later, maybe after
succeeding use/unuse calls, once use_count drops to zero, you can
unload the implementation again. The type system makes sure to call
g_type_plugin_use() and g_type_plugin_complete_type_info() again
when the type is needed again.

#GTypeModule is an implementation of #GTypePlugin that already
implements most of this except for the actual module loading and
unloading. It even handles multiple registered types per module."""
    
    def complete_interface_info(self, instance_type=None, interface_type=None, info=None):
        """        Calls the @complete_interface_info function from the
        #GTypePluginClass of @plugin. There should be no need to use this
        function outside of the GObject type system itself.
        @param instance_type: the #GType of an instantiable type to which the interface  is added
        @param interface_type: the #GType of the interface whose info is completed
        @param info: the #GInterfaceInfo to fill in
        @type instance_type: GType
        @type interface_type: GType
        @type info: InterfaceInfo
        @returns: 
        @rtype: None
        """
        return object
    
    def complete_type_info(self, g_type=None, info=None, value_table=None):
        """        Calls the @complete_type_info function from the #GTypePluginClass of @plugin.
        There should be no need to use this function outside of the GObject
        type system itself.
        @param g_type: the #GType whose info is completed
        @param info: the #GTypeInfo struct to fill in
        @param value_table: the #GTypeValueTable to fill in
        @type g_type: GType
        @type info: TypeInfo
        @type value_table: TypeValueTable
        @returns: 
        @rtype: None
        """
        return object
    
    def unuse(self):
        """        Calls the @unuse_plugin function from the #GTypePluginClass of
        @plugin.  There should be no need to use this function outside of
        the GObject type system itself.
        @returns: 
        @rtype: None
        """
        return object
    
    def use(self):
        """        Calls the @use_plugin function from the #GTypePluginClass of
        @plugin.  There should be no need to use this function outside of
        the GObject type system itself.
        @returns: 
        @rtype: None
        """
        return object


class TypePluginClass():
    """The #GTypePlugin interface is used by the type system in order to handle
the lifecycle of dynamically loaded types."""

    @property
    def base_iface(self):
        return object

    @property
    def use_plugin(self):
        return object

    @property
    def unuse_plugin(self):
        return object

    @property
    def complete_type_info(self):
        return object

    @property
    def complete_interface_info(self):
        return object


class TypeQuery():
    """A structure holding information for a specific type.
It is filled in by the g_type_query() function."""

    @property
    def type(self):
        return object

    @property
    def type_name(self):
        return object

    @property
    def class_size(self):
        return object

    @property
    def instance_size(self):
        return object


class TypeValueTable():
    """The #GTypeValueTable provides the functions required by the #GValue
implementation, to serve as a container for values of a type."""
    @staticmethod
    def peek(type=None):
        """        Returns the location of the #GTypeValueTable associated with @type.
        
        Note that this function should only be used from source code
        that implements or has internal knowledge of the implementation of
        @type.
        @param type: a #GType
        @type type: GType
        @returns: location of the #GTypeValueTable associated with @type or
     %NULL if there is no #GTypeValueTable associated with @type
        @rtype: TypeValueTable
        """
        return object

    @property
    def value_init(self):
        return object

    @property
    def value_free(self):
        return object

    @property
    def value_copy(self):
        return object

    @property
    def value_peek_pointer(self):
        return object

    @property
    def collect_format(self):
        return object

    @property
    def collect_value(self):
        return object

    @property
    def lcopy_format(self):
        return object

    @property
    def lcopy_value(self):
        return object


class Value():
    """An opaque structure used to hold different types of values.
The data within the structure has protected scope: it is accessible only
to functions within a #GTypeValueTable structure, or implementations of
the g_value_*() API. That is, code portions which implement new fundamental
types.
#GValue users cannot make any assumptions about how data is stored
within the 2 element @data union, and the @g_type member should
only be accessed through the G_VALUE_TYPE() macro."""
    
    def copy(self, dest_value=None):
        """        Copies the value of @src_value into @dest_value.
        @param dest_value: An initialized #GValue structure of the same type as @src_value.
        @type dest_value: Value
        @returns: 
        @rtype: None
        """
        return object
    
    def dup_boxed(self):
        """        Get the contents of a %G_TYPE_BOXED derived #GValue.  Upon getting,
        the boxed value is duplicated and needs to be later freed with
        g_boxed_free(), e.g. like: g_boxed_free (G_VALUE_TYPE (@value),
        return_value);
        @returns: boxed contents of @value
        @rtype: gpointer
        """
        return object
    
    def dup_object(self):
        """        Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing
        its reference count. If the contents of the #GValue are %NULL, then
        %NULL will be returned.
        @returns: object content of @value,
          should be unreferenced when no longer needed.
        @rtype: Object
        """
        return object
    
    def dup_param(self):
        """        Get the contents of a %G_TYPE_PARAM #GValue, increasing its
        reference count.
        @returns: #GParamSpec content of @value, should be unreferenced when
          no longer needed.
        @rtype: ParamSpec
        """
        return object
    
    def dup_string(self):
        """        Get a copy the contents of a %G_TYPE_STRING #GValue.
        @returns: a newly allocated copy of the string content of @value
        @rtype: str
        """
        return object
    
    def dup_variant(self):
        """        Get the contents of a variant #GValue, increasing its refcount. The returned
        #GVariant is never floating.
        @returns: variant contents of @value (may be %NULL);
    should be unreffed using g_variant_unref() when no longer needed
        @rtype: GLib.Variant
        """
        return object
    
    def fits_pointer(self):
        """        Determines if @value will fit inside the size of a pointer value.
        This is an internal function introduced mainly for C marshallers.
        @returns: %TRUE if @value will fit inside a pointer value.
        @rtype: bool
        """
        return object
    
    def get_boolean(self):
        """        Get the contents of a %G_TYPE_BOOLEAN #GValue.
        @returns: boolean contents of @value
        @rtype: bool
        """
        return object
    
    def get_boxed(self):
        """        Get the contents of a %G_TYPE_BOXED derived #GValue.
        @returns: boxed contents of @value
        @rtype: gpointer
        """
        return object
    
    def get_char(self):
        """        Do not use this function; it is broken on platforms where the %char
        type is unsigned, such as ARM and PowerPC.  See g_value_get_schar().
        
        Get the contents of a %G_TYPE_CHAR #GValue.
        @returns: character contents of @value
        @rtype: str
        """
        return object
    
    def get_double(self):
        """        Get the contents of a %G_TYPE_DOUBLE #GValue.
        @returns: double contents of @value
        @rtype: float
        """
        return object
    
    def get_enum(self):
        """        Get the contents of a %G_TYPE_ENUM #GValue.
        @returns: enum contents of @value
        @rtype: int
        """
        return object
    
    def get_flags(self):
        """        Get the contents of a %G_TYPE_FLAGS #GValue.
        @returns: flags contents of @value
        @rtype: int
        """
        return object
    
    def get_float(self):
        """        Get the contents of a %G_TYPE_FLOAT #GValue.
        @returns: float contents of @value
        @rtype: float
        """
        return object
    
    def get_gtype(self):
        """        Get the contents of a %G_TYPE_GTYPE #GValue.
        @returns: the #GType stored in @value
        @rtype: GType
        """
        return object
    
    def get_int(self):
        """        Get the contents of a %G_TYPE_INT #GValue.
        @returns: integer contents of @value
        @rtype: int
        """
        return object
    
    def get_int64(self):
        """        Get the contents of a %G_TYPE_INT64 #GValue.
        @returns: 64bit integer contents of @value
        @rtype: int
        """
        return object
    
    def get_long(self):
        """        Get the contents of a %G_TYPE_LONG #GValue.
        @returns: long integer contents of @value
        @rtype: long
        """
        return object
    
    def get_object(self):
        """        Get the contents of a %G_TYPE_OBJECT derived #GValue.
        @returns: object contents of @value
        @rtype: Object
        """
        return object
    
    def get_param(self):
        """        Get the contents of a %G_TYPE_PARAM #GValue.
        @returns: #GParamSpec content of @value
        @rtype: ParamSpec
        """
        return object
    
    def get_pointer(self):
        """        Get the contents of a pointer #GValue.
        @returns: pointer contents of @value
        @rtype: gpointer
        """
        return object
    
    def get_schar(self):
        """        Get the contents of a %G_TYPE_CHAR #GValue.
        @returns: signed 8 bit integer contents of @value
        @rtype: gint8
        """
        return object
    
    def get_string(self):
        """        Get the contents of a %G_TYPE_STRING #GValue.
        @returns: string content of @value
        @rtype: str
        """
        return object
    
    def get_uchar(self):
        """        Get the contents of a %G_TYPE_UCHAR #GValue.
        @returns: unsigned character contents of @value
        @rtype: guint8
        """
        return object
    
    def get_uint(self):
        """        Get the contents of a %G_TYPE_UINT #GValue.
        @returns: unsigned integer contents of @value
        @rtype: int
        """
        return object
    
    def get_uint64(self):
        """        Get the contents of a %G_TYPE_UINT64 #GValue.
        @returns: unsigned 64bit integer contents of @value
        @rtype: int
        """
        return object
    
    def get_ulong(self):
        """        Get the contents of a %G_TYPE_ULONG #GValue.
        @returns: unsigned long integer contents of @value
        @rtype: long
        """
        return object
    
    def get_variant(self):
        """        Get the contents of a variant #GValue.
        @returns: variant contents of @value (may be %NULL)
        @rtype: GLib.Variant
        """
        return object
    
    def init(self, g_type=None):
        """        Initializes @value with the default value of @type.
        @param g_type: Type the #GValue should hold values of.
        @type g_type: GType
        @returns: the #GValue structure that has been passed in
        @rtype: Value
        """
        return object
    
    def init_from_instance(self, instance=None):
        """        Initializes and sets @value from an instantiatable type via the
        value_table's collect_value() function.
        
        Note: The @value will be initialised with the exact type of
        @instance.  If you wish to set the @value's type to a different GType
        (such as a parent class GType), you need to manually call
        g_value_init() and g_value_set_instance().
        @param instance: the instance
        @type instance: TypeInstance
        @returns: 
        @rtype: None
        """
        return object
    
    def peek_pointer(self):
        """        Returns the value contents as pointer. This function asserts that
        g_value_fits_pointer() returned %TRUE for the passed in value.
        This is an internal function introduced mainly for C marshallers.
        @returns: the value contents as pointer
        @rtype: gpointer
        """
        return object
    
    def reset(self):
        """        Clears the current value in @value and resets it to the default value
        (as if the value had just been initialized).
        @returns: the #GValue structure that has been passed in
        @rtype: Value
        """
        return object
    
    def set_boolean(self, v_boolean=None):
        """        Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
        @param v_boolean: boolean value to be set
        @type v_boolean: bool
        @returns: 
        @rtype: None
        """
        return object
    
    def set_boxed(self, v_boxed=None):
        """        Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.
        @param v_boxed: boxed value to be set
        @type v_boxed: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_boxed_take_ownership(self, v_boxed=None):
        """        This is an internal function introduced mainly for C marshallers.
        @param v_boxed: duplicated unowned boxed value to be set
        @type v_boxed: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_char(self, v_char=None):
        """        Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
        @param v_char: character value to be set
        @type v_char: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_double(self, v_double=None):
        """        Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
        @param v_double: double value to be set
        @type v_double: float
        @returns: 
        @rtype: None
        """
        return object
    
    def set_enum(self, v_enum=None):
        """        Set the contents of a %G_TYPE_ENUM #GValue to @v_enum.
        @param v_enum: enum value to be set
        @type v_enum: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_flags(self, v_flags=None):
        """        Set the contents of a %G_TYPE_FLAGS #GValue to @v_flags.
        @param v_flags: flags value to be set
        @type v_flags: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_float(self, v_float=None):
        """        Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
        @param v_float: float value to be set
        @type v_float: float
        @returns: 
        @rtype: None
        """
        return object
    
    def set_gtype(self, v_gtype=None):
        """        Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
        @param v_gtype: #GType to be set
        @type v_gtype: GType
        @returns: 
        @rtype: None
        """
        return object
    
    def set_instance(self, instance=None):
        """        Sets @value from an instantiatable type via the
        value_table's collect_value() function.
        @param instance: the instance
        @type instance: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_int(self, v_int=None):
        """        Set the contents of a %G_TYPE_INT #GValue to @v_int.
        @param v_int: integer value to be set
        @type v_int: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_int64(self, v_int64=None):
        """        Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
        @param v_int64: 64bit integer value to be set
        @type v_int64: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_long(self, v_long=None):
        """        Set the contents of a %G_TYPE_LONG #GValue to @v_long.
        @param v_long: long integer value to be set
        @type v_long: long
        @returns: 
        @rtype: None
        """
        return object
    
    def set_object(self, v_object=None):
        """        Set the contents of a %G_TYPE_OBJECT derived #GValue to @v_object.
        
        g_value_set_object() increases the reference count of @v_object
        (the #GValue holds a reference to @v_object).  If you do not wish
        to increase the reference count of the object (i.e. you wish to
        pass your current reference to the #GValue because you no longer
        need it), use g_value_take_object() instead.
        
        It is important that your #GValue holds a reference to @v_object (either its
        own, or one it has taken) to ensure that the object won't be destroyed while
        the #GValue still exists).
        @param v_object: object value to be set
        @type v_object: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set_object_take_ownership(self, v_object=None):
        """        This is an internal function introduced mainly for C marshallers.
        @param v_object: object value to be set
        @type v_object: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_param(self, param=None):
        """        Set the contents of a %G_TYPE_PARAM #GValue to @param.
        @param param: the #GParamSpec to be set
        @type param: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def set_param_take_ownership(self, param=None):
        """        This is an internal function introduced mainly for C marshallers.
        @param param: the #GParamSpec to be set
        @type param: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def set_pointer(self, v_pointer=None):
        """        Set the contents of a pointer #GValue to @v_pointer.
        @param v_pointer: pointer value to be set
        @type v_pointer: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_schar(self, v_char=None):
        """        Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
        @param v_char: signed 8 bit integer to be set
        @type v_char: gint8
        @returns: 
        @rtype: None
        """
        return object
    
    def set_static_boxed(self, v_boxed=None):
        """        Set the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed.
        The boxed value is assumed to be static, and is thus not duplicated
        when setting the #GValue.
        @param v_boxed: static boxed value to be set
        @type v_boxed: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def set_static_string(self, v_string=None):
        """        Set the contents of a %G_TYPE_STRING #GValue to @v_string.
        The string is assumed to be static, and is thus not duplicated
        when setting the #GValue.
        @param v_string: static string to be set
        @type v_string: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_string(self, v_string=None):
        """        Set the contents of a %G_TYPE_STRING #GValue to @v_string.
        @param v_string: caller-owned string to be duplicated for the #GValue
        @type v_string: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_string_take_ownership(self, v_string=None):
        """        This is an internal function introduced mainly for C marshallers.
        @param v_string: duplicated unowned string to be set
        @type v_string: str
        @returns: 
        @rtype: None
        """
        return object
    
    def set_uchar(self, v_uchar=None):
        """        Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
        @param v_uchar: unsigned character value to be set
        @type v_uchar: guint8
        @returns: 
        @rtype: None
        """
        return object
    
    def set_uint(self, v_uint=None):
        """        Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
        @param v_uint: unsigned integer value to be set
        @type v_uint: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_uint64(self, v_uint64=None):
        """        Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
        @param v_uint64: unsigned 64bit integer value to be set
        @type v_uint64: int
        @returns: 
        @rtype: None
        """
        return object
    
    def set_ulong(self, v_ulong=None):
        """        Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
        @param v_ulong: unsigned long integer value to be set
        @type v_ulong: long
        @returns: 
        @rtype: None
        """
        return object
    
    def set_variant(self, variant=None):
        """        Set the contents of a variant #GValue to @variant.
        If the variant is floating, it is consumed.
        @param variant: a #GVariant, or %NULL
        @type variant: GLib.Variant
        @returns: 
        @rtype: None
        """
        return object
    
    def take_boxed(self, v_boxed=None):
        """        Sets the contents of a %G_TYPE_BOXED derived #GValue to @v_boxed
        and takes over the ownership of the callers reference to @v_boxed;
        the caller doesn't have to unref it any more.
        @param v_boxed: duplicated unowned boxed value to be set
        @type v_boxed: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def take_object(self, v_object=None):
        """        Sets the contents of a %G_TYPE_OBJECT derived #GValue to @v_object
        and takes over the ownership of the callers reference to @v_object;
        the caller doesn't have to unref it any more (i.e. the reference
        count of the object is not increased).
        
        If you want the #GValue to hold its own reference to @v_object, use
        g_value_set_object() instead.
        @param v_object: object value to be set
        @type v_object: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def take_param(self, param=None):
        """        Sets the contents of a %G_TYPE_PARAM #GValue to @param and takes
        over the ownership of the callers reference to @param; the caller
        doesn't have to unref it any more.
        @param param: the #GParamSpec to be set
        @type param: ParamSpec
        @returns: 
        @rtype: None
        """
        return object
    
    def take_string(self, v_string=None):
        """        Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
        @param v_string: string to take ownership of
        @type v_string: str
        @returns: 
        @rtype: None
        """
        return object
    
    def take_variant(self, variant=None):
        """        Set the contents of a variant #GValue to @variant, and takes over
        the ownership of the caller's reference to @variant;
        the caller doesn't have to unref it any more (i.e. the reference
        count of the variant is not increased).
        
        If @variant was floating then its floating reference is converted to
        a hard reference.
        
        If you want the #GValue to hold its own reference to @variant, use
        g_value_set_variant() instead.
        
        This is an internal function introduced mainly for C marshallers.
        @param variant: a #GVariant, or %NULL
        @type variant: GLib.Variant
        @returns: 
        @rtype: None
        """
        return object
    
    def transform(self, dest_value=None):
        """        Tries to cast the contents of @src_value into a type appropriate
        to store in @dest_value, e.g. to transform a %G_TYPE_INT value
        into a %G_TYPE_FLOAT value. Performing transformations between
        value types might incur precision lossage. Especially
        transformations into strings might reveal seemingly arbitrary
        results and shouldn't be relied upon for production code (such
        as rcfile value or object property serialization).
        @param dest_value: Target value.
        @type dest_value: Value
        @returns: Whether a transformation rule was found and could be applied.  Upon failing transformations, @dest_value is left untouched.
        @rtype: bool
        """
        return object
    
    def unset(self):
        """        Clears the current value in @value (if any) and "unsets" the type,
        this releases all resources associated with this GValue. An unset
        value is the same as an uninitialized (zero-filled) #GValue
        structure.
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def register_transform_func(src_type=None, dest_type=None, transform_func=None):
        """        Registers a value transformation function for use in g_value_transform().
        A previously registered transformation function for @src_type and @dest_type
        will be replaced.
        @param src_type: Source type.
        @param dest_type: Target type.
        @param transform_func: a function which transforms values of type @src_type  into value of type @dest_type
        @type src_type: GType
        @type dest_type: GType
        @type transform_func: ValueTransform
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def type_compatible(src_type=None, dest_type=None):
        """        Returns whether a #GValue of type @src_type can be copied into
        a #GValue of type @dest_type.
        @param src_type: source type to be copied.
        @param dest_type: destination type for copying.
        @type src_type: GType
        @type dest_type: GType
        @returns: %TRUE if g_value_copy() is possible with @src_type and @dest_type.
        @rtype: bool
        """
        return object
    @staticmethod
    def type_transformable(src_type=None, dest_type=None):
        """        Check whether g_value_transform() is able to transform values
        of type @src_type into values of type @dest_type. Note that for
        the types to be transformable, they must be compatible or a
        transformation function must be registered.
        @param src_type: Source type.
        @param dest_type: Target type.
        @type src_type: GType
        @type dest_type: GType
        @returns: %TRUE if the transformation is possible, %FALSE otherwise.
        @rtype: bool
        """
        return object

    @property
    def g_type(self):
        return object

    @property
    def data(self):
        return object


class ValueArray():
    """A #GValueArray contains an array of #GValue elements."""
    
    def __init__(self, n_prealloced=None):
        """        Allocate and initialize a new #GValueArray, optionally preserve space
        for @n_prealloced elements. New arrays always contain 0 elements,
        regardless of the value of @n_prealloced.
        @param n_prealloced: number of values to preallocate space for
        @type n_prealloced: int
        @returns: Newly created ValueArray
        @rtype: ValueArray
        """
        return object
    @staticmethod
    def new(n_prealloced=None):
        """        Allocate and initialize a new #GValueArray, optionally preserve space
        for @n_prealloced elements. New arrays always contain 0 elements,
        regardless of the value of @n_prealloced.
        @param n_prealloced: number of values to preallocate space for
        @type n_prealloced: int
        @returns: Newly created ValueArray
        @rtype: ValueArray
        """
        return object
    
    def append(self, value=None):
        """        Insert a copy of @value as last element of @value_array. If @value is
        %NULL, an uninitialized value is appended.
        @param value: #GValue to copy into #GValueArray, or %NULL
        @type value: Value
        @returns: the #GValueArray passed in as @value_array
        @rtype: ValueArray
        """
        return object
    
    def copy(self):
        """        Construct an exact copy of a #GValueArray by duplicating all its
        contents.
        @returns: Newly allocated copy of #GValueArray
        @rtype: ValueArray
        """
        return object
    
    def free(self):
        """        Free a #GValueArray including its contents.
        @returns: 
        @rtype: None
        """
        return object
    
    def get_nth(self, index_=None):
        """        Return a pointer to the value at @index_ containd in @value_array.
        @param index_: index of the value of interest
        @type index_: int
        @returns: pointer to a value at @index_ in @value_array
        @rtype: Value
        """
        return object
    
    def insert(self, index_=None, value=None):
        """        Insert a copy of @value at specified position into @value_array. If @value
        is %NULL, an uninitialized value is inserted.
        @param index_: insertion position, must be <= value_array->;n_values
        @param value: #GValue to copy into #GValueArray, or %NULL
        @type index_: int
        @type value: Value
        @returns: the #GValueArray passed in as @value_array
        @rtype: ValueArray
        """
        return object
    
    def prepend(self, value=None):
        """        Insert a copy of @value as first element of @value_array. If @value is
        %NULL, an uninitialized value is prepended.
        @param value: #GValue to copy into #GValueArray, or %NULL
        @type value: Value
        @returns: the #GValueArray passed in as @value_array
        @rtype: ValueArray
        """
        return object
    
    def remove(self, index_=None):
        """        Remove the value at position @index_ from @value_array.
        @param index_: position of value to remove, which must be less than     @value_array->n_values
        @type index_: int
        @returns: the #GValueArray passed in as @value_array
        @rtype: ValueArray
        """
        return object
    
    def sort(self, compare_func=None):
        """        Sort @value_array using @compare_func to compare the elements according to
        the semantics of #GCompareFunc.
        
        The current implementation uses the same sorting algorithm as standard
        C qsort() function.
        @param compare_func: function to compare elements
        @type compare_func: GLib.CompareFunc
        @returns: the #GValueArray passed in as @value_array
        @rtype: ValueArray
        """
        return object
    
    def sort_with_data(self, compare_func=None, user_data=None):
        """        Sort @value_array using @compare_func to compare the elements according
        to the semantics of #GCompareDataFunc.
        
        The current implementation uses the same sorting algorithm as standard
        C qsort() function.
        @param compare_func: function to compare elements
        @param user_data: extra data argument provided for @compare_func
        @type compare_func: GLib.CompareDataFunc
        @type user_data: gpointer
        @returns: the #GValueArray passed in as @value_array
        @rtype: ValueArray
        """
        return object

    @property
    def n_values(self):
        return object

    @property
    def values(self):
        return object

    @property
    def n_prealloced(self):
        return object


class WeakRef():
    """A structure containing a weak reference to a #GObject.  It can either
be empty (i.e. point to %NULL), or point to an object for as long as
at least one "strong" reference to that object exists. Before the
object's #GObjectClass.dispose method is called, every #GWeakRef
associated with becomes empty (i.e. points to %NULL).

Like #GValue, #GWeakRef can be statically allocated, stack- or
heap-allocated, or embedded in larger structures.

Unlike g_object_weak_ref() and g_object_add_weak_pointer(), this weak
reference is thread-safe: converting a weak pointer to a reference is
atomic with respect to invalidation of weak pointers to destroyed
objects.

If the object's #GObjectClass.dispose method results in additional
references to the object being held, any #GWeakRefs taken
before it was disposed will continue to point to %NULL.  If
#GWeakRefs are taken after the object is disposed and
re-referenced, they will continue to point to it until its refcount
goes back to zero, at which point they too will be invalidated."""
    
    def clear(self):
        """        Frees resources associated with a non-statically-allocated #GWeakRef.
        After this call, the #GWeakRef is left in an undefined state.
        
        You should only call this on a #GWeakRef that previously had
        g_weak_ref_init() called on it.
        @returns: 
        @rtype: None
        """
        return object
    
    def get(self):
        """        If @weak_ref is not empty, atomically acquire a strong
        reference to the object it points to, and return that reference.
        
        This function is needed because of the potential race between taking
        the pointer value and g_object_ref() on it, if the object was losing
        its last reference at the same time in a different thread.
        
        The caller should release the resulting reference in the usual way,
        by using g_object_unref().
        @returns: the object pointed to
     by @weak_ref, or %NULL if it was empty
        @rtype: Object
        """
        return object
    
    def init(self, object=None):
        """        Initialise a non-statically-allocated #GWeakRef.
        
        This function also calls g_weak_ref_set() with @object on the
        freshly-initialised weak reference.
        
        This function should always be matched with a call to
        g_weak_ref_clear().  It is not necessary to use this function for a
        #GWeakRef in static storage because it will already be
        properly initialised.  Just use g_weak_ref_set() directly.
        @param object: a #GObject or %NULL
        @type object: Object
        @returns: 
        @rtype: None
        """
        return object
    
    def set(self, object=None):
        """        Change the object to which @weak_ref points, or set it to
        %NULL.
        
        You must own a strong reference on @object while calling this
        function.
        @param object: a #GObject or %NULL
        @type object: Object
        @returns: 
        @rtype: None
        """
        return object


class Binding(Object):
    """#GBinding is the representation of a binding between a property on a
#GObject instance (or source) and another property on another #GObject
instance (or target). Whenever the source property changes, the same
value is applied to the target property; for instance, the following
binding:

|[<!-- language="C" -->
  g_object_bind_property (object1, "property-a",
                          object2, "property-b",
                          G_BINDING_DEFAULT);
]|

will cause the property named "property-b" of @object2 to be updated
every time g_object_set() or the specific accessor changes the value of
the property "property-a" of @object1.

It is possible to create a bidirectional binding between two properties
of two #GObject instances, so that if either property changes, the
other is updated as well, for instance:

|[<!-- language="C" -->
  g_object_bind_property (object1, "property-a",
                          object2, "property-b",
                          G_BINDING_BIDIRECTIONAL);
]|

will keep the two properties in sync.

It is also possible to set a custom transformation function (in both
directions, in case of a bidirectional binding) to apply a custom
transformation from the source value to the target value before
applying it; for instance, the following binding:

|[<!-- language="C" -->
  g_object_bind_property_full (adjustment1, "value",
                               adjustment2, "value",
                               G_BINDING_BIDIRECTIONAL,
                               celsius_to_fahrenheit,
                               fahrenheit_to_celsius,
                               NULL, NULL);
]|

will keep the "value" property of the two adjustments in sync; the
@celsius_to_fahrenheit function will be called whenever the "value"
property of @adjustment1 changes and will transform the current value
of the property before applying it to the "value" property of @adjustment2.

Vice versa, the @fahrenheit_to_celsius function will be called whenever
the "value" property of @adjustment2 changes, and will transform the
current value of the property before applying it to the "value" property
of @adjustment1.

Note that #GBinding does not resolve cycles by itself; a cycle like

|[
  object1:propertyA -> object2:propertyB
  object2:propertyB -> object3:propertyC
  object3:propertyC -> object1:propertyA
]|

might lead to an infinite loop. The loop, in this particular case,
can be avoided if the objects emit the #GObject::notify signal only
if the value has effectively been changed. A binding is implemented
using the #GObject::notify signal, so it is susceptible to all the
various ways of blocking a signal emission, like g_signal_stop_emission()
or g_signal_handler_block().

A binding will be severed, and the resources it allocates freed, whenever
either one of the #GObject instances it refers to are finalized, or when
the #GBinding instance loses its last reference.

Bindings for languages with garbage collection can use
g_binding_unbind() to explicitly release a binding between the source
and target properties, instead of relying on the last reference on the
binding, source, and target instances to drop.

#GBinding is available since GObject 2.26"""
    
    def get_flags(self):
        """        Retrieves the flags passed when constructing the #GBinding.
        @returns: the #GBindingFlags used by the #GBinding
        @rtype: BindingFlags
        """
        return object
    
    def get_source(self):
        """        Retrieves the #GObject instance used as the source of the binding.
        @returns: the source #GObject
        @rtype: Object
        """
        return object
    
    def get_source_property(self):
        """        Retrieves the name of the property of #GBinding:source used as the source
        of the binding.
        @returns: the name of the source property
        @rtype: str
        """
        return object
    
    def get_target(self):
        """        Retrieves the #GObject instance used as the target of the binding.
        @returns: the target #GObject
        @rtype: Object
        """
        return object
    
    def get_target_property(self):
        """        Retrieves the name of the property of #GBinding:target used as the target
        of the binding.
        @returns: the name of the target property
        @rtype: str
        """
        return object
    
    def unbind(self):
        """        Explicitly releases the binding between the source and the target
        property expressed by @binding.
        
        This function will release the reference that is being held on
        the @binding instance; if you want to hold on to the #GBinding instance
        after calling g_binding_unbind(), you will need to hold a reference
        to it.
        @returns: 
        @rtype: None
        """
        return object


class InitiallyUnowned(Object):
    """All the fields in the GInitiallyUnowned structure
are private to the #GInitiallyUnowned implementation and should never be
accessed directly."""

    @property
    def g_type_instance(self):
        return object

    @property
    def ref_count(self):
        return object

    @property
    def qdata(self):
        return object


class TypeModule(Object, TypePlugin):
    """#GTypeModule provides a simple implementation of the #GTypePlugin
interface. The model of #GTypeModule is a dynamically loaded module
which implements some number of types and interface implementations.
When the module is loaded, it registers its types and interfaces
using g_type_module_register_type() and g_type_module_add_interface().
As long as any instances of these types and interface implementations
are in use, the module is kept loaded. When the types and interfaces
are gone, the module may be unloaded. If the types and interfaces
become used again, the module will be reloaded. Note that the last
unref cannot happen in module code, since that would lead to the
caller's code being unloaded before g_object_unref() returns to it.

Keeping track of whether the module should be loaded or not is done by
using a use count - it starts at zero, and whenever it is greater than
zero, the module is loaded. The use count is maintained internally by
the type system, but also can be explicitly controlled by
g_type_module_use() and g_type_module_unuse(). Typically, when loading
a module for the first type, g_type_module_use() will be used to load
it so that it can initialize its types. At some later point, when the
module no longer needs to be loaded except for the type
implementations it contains, g_type_module_unuse() is called.

#GTypeModule does not actually provide any implementation of module
loading and unloading. To create a particular module type you must
derive from #GTypeModule and implement the load and unload functions
in #GTypeModuleClass."""
    
    def load(self):
        """        
        @returns: 
        @rtype: bool
        """
        return object
    
    def unload(self):
        """        
        @returns: 
        @rtype: None
        """
        return object
    
    def add_interface(self, instance_type=None, interface_type=None, interface_info=None):
        """        Registers an additional interface for a type, whose interface lives
        in the given type plugin. If the interface was already registered
        for the type in this plugin, nothing will be done.
        
        As long as any instances of the type exist, the type plugin will
        not be unloaded.
        
        Since 2.56 if @module is %NULL this will call g_type_add_interface_static()
        instead. This can be used when making a static build of the module.
        @param instance_type: type to which to add the interface.
        @param interface_type: interface type to add
        @param interface_info: type information structure
        @type instance_type: GType
        @type interface_type: GType
        @type interface_info: InterfaceInfo
        @returns: 
        @rtype: None
        """
        return object
    
    def register_enum(self, name=None, const_static_values=None):
        """        Looks up or registers an enumeration that is implemented with a particular
        type plugin. If a type with name @type_name was previously registered,
        the #GType identifier for the type is returned, otherwise the type
        is newly registered, and the resulting #GType identifier returned.
        
        As long as any instances of the type exist, the type plugin will
        not be unloaded.
        
        Since 2.56 if @module is %NULL this will call g_type_register_static()
        instead. This can be used when making a static build of the module.
        @param name: name for the type
        @param const_static_values: an array of #GEnumValue structs for the                       possible enumeration values. The array is                       terminated by a struct with all members being                       0.
        @type name: str
        @type const_static_values: EnumValue
        @returns: the new or existing type ID
        @rtype: GType
        """
        return object
    
    def register_flags(self, name=None, const_static_values=None):
        """        Looks up or registers a flags type that is implemented with a particular
        type plugin. If a type with name @type_name was previously registered,
        the #GType identifier for the type is returned, otherwise the type
        is newly registered, and the resulting #GType identifier returned.
        
        As long as any instances of the type exist, the type plugin will
        not be unloaded.
        
        Since 2.56 if @module is %NULL this will call g_type_register_static()
        instead. This can be used when making a static build of the module.
        @param name: name for the type
        @param const_static_values: an array of #GFlagsValue structs for the                       possible flags values. The array is                       terminated by a struct with all members being                       0.
        @type name: str
        @type const_static_values: FlagsValue
        @returns: the new or existing type ID
        @rtype: GType
        """
        return object
    
    def register_type(self, parent_type=None, type_name=None, type_info=None, flags=None):
        """        Looks up or registers a type that is implemented with a particular
        type plugin. If a type with name @type_name was previously registered,
        the #GType identifier for the type is returned, otherwise the type
        is newly registered, and the resulting #GType identifier returned.
        
        When reregistering a type (typically because a module is unloaded
        then reloaded, and reinitialized), @module and @parent_type must
        be the same as they were previously.
        
        As long as any instances of the type exist, the type plugin will
        not be unloaded.
        
        Since 2.56 if @module is %NULL this will call g_type_register_static()
        instead. This can be used when making a static build of the module.
        @param parent_type: the type for the parent class
        @param type_name: name for the type
        @param type_info: type information structure
        @param flags: flags field providing details about the type
        @type parent_type: GType
        @type type_name: str
        @type type_info: TypeInfo
        @type flags: TypeFlags
        @returns: the new or existing type ID
        @rtype: GType
        """
        return object
    
    def set_name(self, name=None):
        """        Sets the name for a #GTypeModule
        @param name: a human-readable name to use in error messages.
        @type name: str
        @returns: 
        @rtype: None
        """
        return object
    
    def unuse(self):
        """        Decreases the use count of a #GTypeModule by one. If the
        result is zero, the module will be unloaded. (However, the
        #GTypeModule will not be freed, and types associated with the
        #GTypeModule are not unregistered. Once a #GTypeModule is
        initialized, it must exist forever.)
        @returns: 
        @rtype: None
        """
        return object
    
    def use(self):
        """        Increases the use count of a #GTypeModule by one. If the
        use count was zero before, the plugin will be loaded.
        If loading the plugin fails, the use count is reset to
        its prior value.
        @returns: %FALSE if the plugin needed to be loaded and  loading the plugin failed.
        @rtype: bool
        """
        return object

    @property
    def parent_instance(self):
        return object

    @property
    def use_count(self):
        return object

    @property
    def type_infos(self):
        return object

    @property
    def interface_infos(self):
        return object

    @property
    def name(self):
        return object
